diff --git a/.eslintrc b/.eslintrc
index a09fe38bc0..f6ba717a45 100755
--- a/.eslintrc
+++ b/.eslintrc
@@ -10,12 +10,12 @@
     "sourceType": "module",
     "ecmaFeatures": {
       "jsx": true
-    },
+    }
   },
   "rules": {
     "strict": 0,
     "curly": 0,
-    "quotes": ["warn", "single"],
+    "quotes": ["warn", "single", {"avoidEscape": true}],
     "no-underscore-dangle": 0,
     "camelcase": [0],
     "new-cap": 0,
diff --git a/dependencies/pip/dev_requirements.txt b/dependencies/pip/dev_requirements.txt
index 4cdac616c0..c7a90683f3 100644
--- a/dependencies/pip/dev_requirements.txt
+++ b/dependencies/pip/dev_requirements.txt
@@ -21,6 +21,7 @@ cookies==2.2.1            # via responses
 cryptography==2.2.2       # via paramiko, pyopenssl
 cssselect==1.0.3          # via pyquery
 cyordereddict==1.0.0
+defusedxml==0.5.0         # via djangorestframework-xml
 dj-database-url==0.4.2
 dj-static==0.0.6
 django-braces==1.11.0
@@ -44,6 +45,7 @@ django-taggit==0.22.0
 django-toolbelt==0.0.1
 django-webpack-loader==0.4.1
 django==1.8.17
+djangorestframework-xml==1.3.0
 djangorestframework==3.5.4
 docutils==0.13.1          # via botocore, statistics
 drf-extensions==0.3.1
diff --git a/dependencies/pip/external_services.txt b/dependencies/pip/external_services.txt
index 8cce303e54..f305b6a835 100644
--- a/dependencies/pip/external_services.txt
+++ b/dependencies/pip/external_services.txt
@@ -22,6 +22,7 @@ cookies==2.2.1            # via responses
 cryptography==2.2.2       # via pyopenssl
 cssselect==1.0.3          # via pyquery
 cyordereddict==1.0.0
+defusedxml==0.5.0         # via djangorestframework-xml
 dj-database-url==0.4.1
 dj-static==0.0.6
 django-braces==1.8.1
@@ -45,6 +46,7 @@ django-taggit==0.22.0
 django-toolbelt==0.0.1
 django-webpack-loader==0.3.0
 django==1.8.13
+djangorestframework-xml==1.3.0
 djangorestframework==3.3.3
 docutils==0.12            # via botocore, statistics
 drf-extensions==0.3.1
diff --git a/dependencies/pip/requirements.in b/dependencies/pip/requirements.in
index e47e23d16b..f66865a7b4 100644
--- a/dependencies/pip/requirements.in
+++ b/dependencies/pip/requirements.in
@@ -43,6 +43,7 @@ django-taggit
 django-storages
 django-private-storage
 djangorestframework
+djangorestframework-xml
 drf-extensions
 gunicorn
 jsonfield
diff --git a/dependencies/pip/requirements.txt b/dependencies/pip/requirements.txt
index 3d5b9804a0..7b5997acf1 100644
--- a/dependencies/pip/requirements.txt
+++ b/dependencies/pip/requirements.txt
@@ -21,6 +21,7 @@ cookies==2.2.1            # via responses
 cryptography==2.2.2       # via pyopenssl
 cssselect==1.0.3          # via pyquery
 cyordereddict==1.0.0
+defusedxml==0.5.0         # via djangorestframework-xml
 dj-database-url==0.4.1
 dj-static==0.0.6
 django-braces==1.8.1
@@ -44,6 +45,7 @@ django-taggit==0.22.0
 django-toolbelt==0.0.1
 django-webpack-loader==0.3.0
 django==1.8.13
+djangorestframework-xml==1.3.0
 djangorestframework==3.3.3
 docutils==0.12            # via botocore, statistics
 drf-extensions==0.3.1
diff --git a/jsapp/js/actions.es6 b/jsapp/js/actions.es6
index 570e0dce5a..462b40da6f 100644
--- a/jsapp/js/actions.es6
+++ b/jsapp/js/actions.es6
@@ -221,6 +221,16 @@ actions.permissions = Reflux.createActions({
   },
 });
 
+actions.hooks = Reflux.createActions({
+  getAll: {children: ['completed', 'failed']},
+  add: {children: ['completed', 'failed']},
+  update: {children: ['completed', 'failed']},
+  delete: {children: ['completed', 'failed']},
+  getLogs: {children: ['completed', 'failed']},
+  retryLog: {children: ['completed', 'failed']},
+  retryLogs: {children: ['completed', 'failed']},
+});
+
 actions.misc = Reflux.createActions({
   checkUsername: {
     asyncResult: true,
@@ -695,4 +705,151 @@ actions.resources.updateSubmissionValidationStatus.listen(function(uid, sid, dat
   });
 });
 
+actions.hooks.getAll.listen((assetUid, callbacks = {}) => {
+  dataInterface.getHooks(assetUid)
+    .done((...args) => {
+      actions.hooks.getAll.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.getAll.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+
+actions.hooks.add.listen((assetUid, data, callbacks = {}) => {
+  dataInterface.addExternalService(assetUid, data)
+    .done((...args) => {
+      actions.hooks.getAll(assetUid);
+      actions.hooks.add.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.add.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+actions.hooks.add.completed.listen((response) => {
+  notify(t('REST Service added successfully'));
+});
+actions.hooks.add.failed.listen((response) => {
+  notify(t('Failed adding REST Service'), 'error');
+});
+
+actions.hooks.update.listen((assetUid, hookUid, data, callbacks = {}) => {
+  dataInterface.updateExternalService(assetUid, hookUid, data)
+    .done((...args) => {
+      actions.hooks.getAll(assetUid);
+      actions.hooks.update.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.update.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+actions.hooks.update.completed.listen((response) => {
+  notify(t('REST Service updated successfully'));
+});
+actions.hooks.update.failed.listen((response) => {
+  notify(t('Failed saving REST Service'), 'error');
+});
+
+actions.hooks.delete.listen((assetUid, hookUid, callbacks = {}) => {
+  dataInterface.deleteExternalService(assetUid, hookUid)
+    .done((...args) => {
+      actions.hooks.getAll(assetUid);
+      actions.hooks.delete.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.delete.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+actions.hooks.delete.completed.listen((response) => {
+  notify(t('REST Service deleted permanently'));
+});
+actions.hooks.delete.failed.listen((response) => {
+  notify(t('Could not delete REST Service'), 'error');
+});
+
+actions.hooks.getLogs.listen((assetUid, hookUid, callbacks = {}) => {
+  dataInterface.getHookLogs(assetUid, hookUid)
+    .done((...args) => {
+      actions.hooks.getLogs.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.getLogs.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+
+actions.hooks.retryLog.listen((assetUid, hookUid, lid, callbacks = {}) => {
+  dataInterface.retryExternalServiceLog(assetUid, hookUid, lid)
+    .done((...args) => {
+      actions.hooks.getLogs(assetUid, hookUid);
+      actions.hooks.retryLog.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.retryLog.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+actions.hooks.retryLog.completed.listen((response) => {
+  notify(t('Submission retried successfully'));
+});
+actions.hooks.retryLog.failed.listen((response) => {
+  notify(t('Retrying submission failed'), 'error');
+});
+
+actions.hooks.retryLogs.listen((assetUid, hookUid, callbacks = {}) => {
+  dataInterface.retryExternalServiceLogs(assetUid, hookUid)
+    .done((...args) => {
+      actions.hooks.retryLogs.completed(...args);
+      if (typeof callbacks.onComplete === 'function') {
+        callbacks.onComplete(...args);
+      }
+    })
+    .fail((...args) => {
+      actions.hooks.getLogs(assetUid, hookUid);
+      actions.hooks.retryLogs.failed(...args);
+      if (typeof callbacks.onFail === 'function') {
+        callbacks.onFail(...args);
+      }
+    });
+});
+actions.hooks.retryLogs.completed.listen((response) => {
+  notify(t(response.detail), 'warning');
+});
+actions.hooks.retryLogs.failed.listen((response) => {
+  notify(t('Retrying all submissions failed'), 'error');
+});
+
 module.exports = actions;
diff --git a/jsapp/js/app.es6 b/jsapp/js/app.es6
index 422baddfc5..3777df3bb0 100644
--- a/jsapp/js/app.es6
+++ b/jsapp/js/app.es6
@@ -317,8 +317,11 @@ export var routes = (
 
         <Route path='settings'>
           <IndexRoute component={FormSubScreens} />
-          <Route path='kobocat' component={FormSubScreens} />
+          <Route path='media' component={FormSubScreens} />
           <Route path='sharing' component={FormSubScreens} />
+          <Route path='rest' component={FormSubScreens} />
+          <Route path='rest/:hookUid' component={FormSubScreens} />
+          <Route path='kobocat' component={FormSubScreens} />
         </Route>
 
         {/* used to force refresh form screens */}
diff --git a/jsapp/js/bem.es6 b/jsapp/js/bem.es6
index 0943a9af22..5783cbc27c 100644
--- a/jsapp/js/bem.es6
+++ b/jsapp/js/bem.es6
@@ -11,6 +11,12 @@ bem.Loading = BEM('loading');
 bem.Loading__inner = bem.Loading.__('inner');
 bem.Loading__msg = bem.Loading.__('msg');
 
+bem.EmptyContent = BEM('empty-content', '<section>');
+bem.EmptyContent__icon = bem.EmptyContent.__('icon', '<i>');
+bem.EmptyContent__title = bem.EmptyContent.__('title', '<h1>');
+bem.EmptyContent__message = bem.EmptyContent.__('message', '<p>');
+bem.EmptyContent__button = bem.EmptyContent.__('button', '<button>');
+
 bem.AssetRow = BEM('asset-row', '<li>');
 bem.AssetRow__cell        = bem.AssetRow.__('cell');
 bem.AssetRow__cellmeta    = bem.AssetRow.__('cellmeta');
@@ -22,6 +28,10 @@ bem.AssetRow__actionIcon  = bem.AssetRow.__('action-icon', '<a>');
 bem.AssetRow__buttons        = bem.AssetRow.__('buttons');
 bem.AssetRow__typeIcon  = bem.AssetRow.__('type-icon', '<span>');
 
+bem.ServiceRow = BEM('service-row');
+bem.ServiceRow__column = bem.ServiceRow.__('column');
+bem.ServiceRow__actionButton = bem.ServiceRow.__('action-button', '<button>');
+
 bem.FormBuilder = bem('formBuilder');
 bem.FormBuilder__row = bem.FormBuilder.__('row');
 bem.FormBuilder__contents = bem.FormBuilder.__('contents');
@@ -239,6 +249,16 @@ bem.TextBox__input = bem.TextBox.__('input', '<input>');
 bem.TextBox__description = bem.TextBox.__('description');
 bem.TextBox__error = bem.TextBox.__('error');
 
+bem.Checkbox = bem('checkbox');
+bem.Checkbox__wrapper = bem.Checkbox.__('wrapper', '<label>');
+bem.Checkbox__input = bem.Checkbox.__('input', '<input>');
+bem.Checkbox__label = bem.Checkbox.__('label', '<span>');
+
+bem.Radio = bem('radio');
+bem.Radio__wrapper = bem.Radio.__('wrapper', '<label>');
+bem.Radio__input = bem.Radio.__('input', '<input>');
+bem.Radio__label = bem.Radio.__('label', '<span>');
+
 bem.PrintOnly = BEM('print-only');
 
 bem.GitRev = BEM('git-rev');
diff --git a/jsapp/js/components/RESTServices.es6 b/jsapp/js/components/RESTServices.es6
new file mode 100644
index 0000000000..e3f5012665
--- /dev/null
+++ b/jsapp/js/components/RESTServices.es6
@@ -0,0 +1,33 @@
+import React from 'react';
+import autoBind from 'react-autobind';
+import DocumentTitle from 'react-document-title';
+import bem from '../bem';
+import RESTServicesList from './RESTServices/RESTServicesList'
+import RESTServiceLogs from './RESTServices/RESTServiceLogs'
+import {t} from '../utils';
+
+export default class RESTServices extends React.Component {
+  constructor(props){
+    super(props);
+    autoBind(this);
+  }
+
+  render() {
+    const docTitle = this.props.asset.name || t('Untitled');
+    if (this.props.hookUid) {
+      return (
+        <DocumentTitle title={`${docTitle} | KoboToolbox`}>
+          <bem.FormView m={'form-settings'} className='rest-services'>
+            <RESTServiceLogs assetUid={this.props.asset.uid} hookUid={this.props.hookUid} />
+          </bem.FormView>
+        </DocumentTitle>
+      );
+    } else {
+      return (
+        <DocumentTitle title={`${docTitle} | KoboToolbox`}>
+          <RESTServicesList assetUid={this.props.asset.uid} />
+        </DocumentTitle>
+      );
+    }
+  }
+};
diff --git a/jsapp/js/components/RESTServices/RESTServiceLogs.es6 b/jsapp/js/components/RESTServices/RESTServiceLogs.es6
new file mode 100644
index 0000000000..4df7525821
--- /dev/null
+++ b/jsapp/js/components/RESTServices/RESTServiceLogs.es6
@@ -0,0 +1,298 @@
+import $ from 'jquery';
+import _ from 'underscore';
+import React from 'react';
+import autoBind from 'react-autobind';
+import reactMixin from 'react-mixin';
+import Reflux from 'reflux';
+import alertify from 'alertifyjs';
+import stores from '../../stores';
+import bem from '../../bem';
+import actions from '../../actions';
+import {dataInterface} from '../../dataInterface';
+import {
+  t,
+  formatTime
+} from '../../utils';
+import {HOOK_LOG_STATUSES} from '../../constants';
+
+export default class RESTServiceLogs extends React.Component {
+  constructor(props){
+    super(props);
+    this.state = {
+      hookName: null,
+      isHookActive: false,
+      assetUid: props.assetUid,
+      hookUid: props.hookUid,
+      isLoadingHook: true,
+      isLoadingLogs: true,
+      logs: []
+    };
+    autoBind(this);
+  }
+
+  componentDidMount() {
+    this.listenTo(
+      actions.hooks.getLogs.completed,
+      this.onLogsUpdated
+    );
+
+    dataInterface.getHook(this.state.assetUid, this.state.hookUid)
+      .done((data) => {
+        this.setState({
+          isLoadingHook: false,
+          hookName: data.name,
+          isHookActive: data.active
+        });
+      })
+      .fail((data) => {
+        this.setState({
+          isLoadingHook: false
+        });
+        alertify.error(t('Could not load REST Service'));
+      });
+
+    actions.hooks.getLogs(
+      this.state.assetUid,
+      this.state.hookUid,
+      {
+        onComplete: (data) => {
+          this.setState({
+            isLoadingLogs: false,
+            logs: data.results
+          });
+        },
+        onFail: (data) => {
+          this.setState({
+            isLoadingLogs: false
+          });
+          alertify.error(t('Could not load REST Service logs'));
+        }
+      }
+    );
+  }
+
+  onLogsUpdated(data) {
+    this.setState({
+      logs: data.results
+    });
+  }
+
+  retryAll(evt) {
+    const failedLogUids = [];
+    this.state.logs.forEach((log) => {
+      if (log.status === HOOK_LOG_STATUSES.FAILED) {
+        failedLogUids.push(log.uid);
+      }
+    });
+    this.overrideLogsStatus(failedLogUids, HOOK_LOG_STATUSES.PENDING);
+
+    actions.hooks.retryLogs(
+      this.state.assetUid,
+      this.state.hookUid,
+      {
+        onComplete: (response) => {
+          this.overrideLogsStatus(response.pending_uids, HOOK_LOG_STATUSES.PENDING);
+        }
+      }
+    );
+  }
+
+  retryLog(log, evt) {
+    // make sure to allow only retrying failed logs
+    if (log.status !== HOOK_LOG_STATUSES.FAILED) {
+      return;
+    }
+
+    this.overrideLogsStatus([log.uid], HOOK_LOG_STATUSES.PENDING);
+
+    actions.hooks.retryLog(
+      this.state.assetUid,
+      this.state.hookUid,
+      log.uid, {
+        onFail: (response) => {
+          if (response.responseJSON && response.responseJSON.detail) {
+            this.overrideLogMessage(log.uid, response.responseJSON.detail);
+          }
+          this.overrideLogsStatus([log.uid], HOOK_LOG_STATUSES.FAILED);
+        }
+      }
+    );
+  }
+
+  overrideLogMessage(logUid, newMessage) {
+    const currentLogs = this.state.logs;
+    currentLogs.forEach((currentLog) => {
+      if (currentLog.uid === logUid) {
+        currentLog.message = newMessage;
+      }
+    });
+    this.setState({
+      logs: currentLogs
+    });
+  }
+
+  // useful to mark logs as pending, before BE tells about it
+  // NOTE: logUids is an array
+  overrideLogsStatus(logUids, newStatus) {
+    const currentLogs = this.state.logs;
+    currentLogs.forEach((currentLog) => {
+      if (logUids.includes(currentLog.uid)) {
+        currentLog.status = newStatus;
+      }
+    });
+    this.setState({
+      logs: currentLogs
+    });
+  }
+
+  showLogInfo(log, evt) {
+    const escapedMessage = $('<div/>').text(log.message).html();
+    alertify.alert(log.uid, `<pre>${escapedMessage}</pre>`);
+  }
+
+  hasAnyFailedLogs() {
+    let hasAny = false;
+    this.state.logs.forEach((log) => {
+      if (log.status === HOOK_LOG_STATUSES.FAILED) {
+        hasAny = true;
+      }
+    });
+    return hasAny;
+  }
+
+  /*
+   * rendering methods
+   */
+
+  renderHeader() {
+    return (
+      <header className='rest-services-list__header'>
+        <a
+          className='rest-services-list__header-back-button'
+          href={`/#/forms/${this.state.assetUid}/settings/rest`}
+        >
+          <i className='k-icon-prev' />
+          {t('Back to REST Services')}
+        </a>
+
+        <h2 className='rest-services-list__header-label rest-services-list__header-label--big'>
+          {this.state.hookName}
+        </h2>
+      </header>
+    )
+  }
+
+  renderEmptyView() {
+    return (
+      <bem.FormView__cell m='rest-services-list' className='rest-services-list--empty'>
+        {this.renderHeader()}
+
+        <bem.EmptyContent>
+          <bem.EmptyContent__message>
+            {t('There are no logs yet')}
+          </bem.EmptyContent__message>
+        </bem.EmptyContent>
+      </bem.FormView__cell>
+    );
+  }
+
+  renderListView() {
+    return (
+      <bem.FormView__cell m='rest-services-list'>
+        {this.renderHeader()}
+
+        <bem.FormView__cell m={['box']}>
+          <bem.ServiceRow m='header'>
+            <bem.ServiceRow__column m='submission'>{t('Submission')}</bem.ServiceRow__column>
+            <bem.ServiceRow__column m='status'>
+              {t('Status')}
+              { this.hasAnyFailedLogs() &&
+                <bem.ServiceRow__actionButton
+                  onClick={this.retryAll.bind(this)}
+                  data-tip={t('Retry all submissions')}
+                  disabled={!this.state.isHookActive}
+                >
+                  <i className='k-icon-replace-all'/>
+                </bem.ServiceRow__actionButton>
+              }
+            </bem.ServiceRow__column>
+            <bem.ServiceRow__column m='date'>{t('Date')}</bem.ServiceRow__column>
+          </bem.ServiceRow>
+
+          {this.state.logs.map((log, n) => {
+            let statusMod = '';
+            let statusLabel = '';
+            if (log.status === HOOK_LOG_STATUSES.SUCCESS) {
+              statusMod = 'success';
+              statusLabel = t('Success');
+            }
+            if (log.status === HOOK_LOG_STATUSES.PENDING) {
+              statusMod = 'pending';
+              statusLabel = t('Pending');
+            }
+            if (log.status === HOOK_LOG_STATUSES.FAILED) {
+              statusMod = 'failed';
+              statusLabel = t('Failed');
+            }
+
+            return (
+              <bem.ServiceRow key={n} >
+                <bem.ServiceRow__column m='submission'>
+                  {log.uid}
+                </bem.ServiceRow__column>
+
+                <bem.ServiceRow__column
+                  m={['status', statusMod]}
+                >
+                  {statusLabel}
+
+                  {log.status === HOOK_LOG_STATUSES.FAILED &&
+                    <bem.ServiceRow__actionButton
+                      disabled={!this.state.isHookActive}
+                      onClick={this.retryLog.bind(this, log)}
+                      data-tip={t('Retry submission')}
+                    >
+                      <i className='k-icon-replace' />
+                    </bem.ServiceRow__actionButton>
+                  }
+
+                  {log.status === HOOK_LOG_STATUSES.FAILED && log.message.length > 0 &&
+                    <bem.ServiceRow__actionButton
+                      onClick={this.showLogInfo.bind(this, log)}
+                      data-tip={t('More info')}
+                    >
+                      <i className='k-icon-information' />
+                    </bem.ServiceRow__actionButton>
+                  }
+                </bem.ServiceRow__column>
+
+                <bem.ServiceRow__column m='date'>
+                  {formatTime(log.date_modified)}
+                </bem.ServiceRow__column>
+              </bem.ServiceRow>
+            );
+          })}
+        </bem.FormView__cell>
+      </bem.FormView__cell>
+    );
+  }
+
+  render() {
+    if (this.state.isLoadingHook || this.state.isLoadingLogs) {
+      return (
+        <bem.Loading>
+          <bem.Loading__inner>
+            <i />
+            {t('loading...')}
+          </bem.Loading__inner>
+        </bem.Loading>
+      )
+    } else if (this.state.logs.length === 0) {
+      return this.renderEmptyView();
+    } else {
+      return this.renderListView();
+    }
+  }
+}
+
+reactMixin(RESTServiceLogs.prototype, Reflux.ListenerMixin);
diff --git a/jsapp/js/components/RESTServices/RESTServicesForm.es6 b/jsapp/js/components/RESTServices/RESTServicesForm.es6
new file mode 100644
index 0000000000..8aeb17cd91
--- /dev/null
+++ b/jsapp/js/components/RESTServices/RESTServicesForm.es6
@@ -0,0 +1,471 @@
+import $ from 'jquery';
+import React from 'react';
+import autoBind from 'react-autobind';
+import alertify from 'alertifyjs';
+import bem from '../../bem';
+import {dataInterface} from '../../dataInterface';
+import actions from '../../actions';
+import stores from '../../stores';
+import Select from 'react-select';
+import Checkbox from '../checkbox';
+import Radio from '../radio';
+import TextBox from '../textBox';
+import {t} from '../../utils';
+
+const EXPORT_TYPES = {
+  JSON: 'json',
+  XML: 'xml'
+};
+const AUTH_OPTIONS = {
+  no_auth: {
+    value: 'no_auth',
+    label: t('No Authorization')
+  },
+  basic_auth: {
+    value: 'basic_auth',
+    label: t('Basic Authorization')
+  }
+};
+
+export default class RESTServicesForm extends React.Component {
+  constructor(props){
+    super(props);
+    this.state = {
+      isLoadingHook: true,
+      isSubmitPending: false,
+      assetUid: props.assetUid,
+      // will be empty if creating new service
+      hookUid: props.hookUid,
+      name: '',
+      nameError: null,
+      endpoint: '',
+      endpointError: null,
+      type: EXPORT_TYPES.JSON,
+      isActive: true,
+      authLevel: null,
+      authOptions: [
+        AUTH_OPTIONS.no_auth,
+        AUTH_OPTIONS.basic_auth
+      ],
+      authUsername: '',
+      authPassword: '',
+      customHeaders: [
+        this.getEmptyHeaderRow()
+      ]
+    };
+    autoBind(this);
+  }
+
+  /*
+   * initialization
+   */
+
+  componentDidMount() {
+    if (this.state.hookUid) {
+      dataInterface.getHook(this.state.assetUid, this.state.hookUid)
+        .done((data) => {
+          const stateUpdate = {
+            isLoadingHook: false,
+            name: data.name,
+            endpoint: data.endpoint,
+            isActive: data.active,
+            type: data.export_type,
+            authLevel: AUTH_OPTIONS[data.auth_level] || null,
+            customHeaders: this.headersObjToArr(data.settings.custom_headers)
+          };
+
+          if (stateUpdate.customHeaders.length === 0) {
+            stateUpdate.customHeaders.push(this.getEmptyHeaderRow());
+          }
+          if (data.settings.username) {
+            stateUpdate.authUsername = data.settings.username;
+          }
+          if (data.settings.password) {
+            stateUpdate.authPassword = data.settings.password;
+          }
+
+          this.setState(stateUpdate);
+        })
+        .fail((data) => {
+          this.setState({isSubmitPending: false});
+          alertify.error(t('Could not load REST Service'));
+        });
+    } else {
+      this.setState({isLoadingHook: false});
+    }
+  }
+
+  /*
+   * helpers
+   */
+
+  getEmptyHeaderRow() {
+    return {name: '', value: ''};
+  }
+
+  headersObjToArr(headersObj) {
+    const headersArr = [];
+    for (let header in headersObj) {
+      if (headersObj.hasOwnProperty(header)) {
+        headersArr.push({
+          name: header,
+          value: headersObj[header]
+        });
+      }
+    }
+    return headersArr;
+  }
+
+  headersArrToObj(headersArr) {
+    const headersObj = {}
+    for (const header of headersArr) {
+      if (header.name) {
+        headersObj[header.name] = header.value;
+      }
+    }
+    return headersObj;
+  }
+
+  /*
+   * user input handling
+   */
+
+  handleNameChange(newName) {
+    this.setState({
+      name: newName,
+      nameError: null
+    });
+  }
+
+  handleEndpointChange(newEndpoint) {
+    this.setState({
+      endpoint: newEndpoint,
+      endpointError: null
+    });
+  }
+
+  handleAuthTypeChange(evt) {this.setState({authLevel: evt});}
+
+  handleAuthUsernameChange(newUsername) {this.setState({authUsername: newUsername});}
+
+  handleAuthPasswordChange(newPassword) {this.setState({authPassword: newPassword});}
+
+  handleActiveChange(isChecked) {this.setState({isActive: isChecked});}
+
+  handleTypeRadioChange(name, value) {this.setState({[name]: value});}
+
+  handleCustomHeaderChange(evt) {
+    const propName = evt.target.name;
+    const propValue = evt.target.value;
+    const index = evt.target.dataset.index;
+    const newCustomHeaders = this.state.customHeaders;
+    if (propName === 'headerName') {
+      newCustomHeaders[index].name = propValue;
+    }
+    if (propName === 'headerValue') {
+      newCustomHeaders[index].value = propValue;
+    }
+    this.setState({customHeaders: newCustomHeaders});
+  }
+
+  /*
+   * submitting form
+   */
+
+  getDataForBackend() {
+    let authLevel = AUTH_OPTIONS.no_auth.value;
+    if (this.state.authLevel !== null) {
+      authLevel = this.state.authLevel.value;
+    }
+
+    const data = {
+      name: this.state.name,
+      endpoint: this.state.endpoint,
+      active: this.state.isActive,
+      export_type: this.state.type,
+      auth_level: authLevel,
+      settings: {
+        custom_headers: this.headersArrToObj(this.state.customHeaders)
+      }
+    };
+
+    if (this.state.authUsername) {
+      data.settings.username = this.state.authUsername;
+    }
+    if (this.state.authPassword) {
+      data.settings.password = this.state.authPassword;
+    }
+
+    return data;
+  }
+
+  validateForm() {
+    let isValid = true;
+    if (this.state.name.trim() === '') {
+      this.setState({nameError: t('Name required')});
+      isValid = false;
+    }
+    if (this.state.endpoint.trim() === '') {
+      this.setState({endpointError: t('URL required')});
+      isValid = false;
+    }
+    return isValid;
+  }
+
+  onSubmit(evt) {
+    evt.preventDefault();
+
+    if (!this.validateForm()) {
+      alertify.error(t('Please enter both name and url of your service.'));
+      return;
+    }
+
+    const callbacks = {
+      onComplete: () => {
+        stores.pageState.hideModal();
+        actions.resources.loadAsset({id: this.state.assetUid});
+      },
+      onFail: () => {
+        this.setState({isSubmitPending: false});
+      },
+    };
+
+    this.setState({isSubmitPending: true});
+    if (this.state.hookUid) {
+      actions.hooks.update(
+        this.state.assetUid,
+        this.state.hookUid,
+        this.getDataForBackend(),
+        callbacks
+      );
+    } else {
+      actions.hooks.add(
+        this.state.assetUid,
+        this.getDataForBackend(),
+        callbacks
+      );
+    }
+    return false;
+  }
+
+  /*
+   * rendering custom headers
+   */
+
+ onCustomHeaderInputKeyPress(evt) {
+   if (evt.key === 'Enter' && evt.currentTarget.name === 'headerName') {
+     evt.preventDefault();
+     $(evt.currentTarget).parent().find('input[name="headerValue"]').focus();
+   }
+   if (evt.key === 'Enter' && evt.currentTarget.name === 'headerValue') {
+     evt.preventDefault();
+     this.addNewCustomHeaderRow();
+   }
+ }
+
+  addNewCustomHeaderRow(evt) {
+    if (evt) {
+      evt.preventDefault();
+    }
+    const newCustomHeaders = this.state.customHeaders;
+    newCustomHeaders.push(this.getEmptyHeaderRow());
+    this.setState({customHeaders: newCustomHeaders});
+    setTimeout(() => {
+      $('input[name="headerName"]').last().focus();
+    }, 0);
+  }
+
+  removeCustomHeaderRow(evt) {
+    evt.preventDefault();
+    const newCustomHeaders = this.state.customHeaders;
+    const rowIndex = evt.currentTarget.dataset.index;
+    newCustomHeaders.splice(rowIndex, 1);
+    if (newCustomHeaders.length === 0) {
+      newCustomHeaders.push(this.getEmptyHeaderRow());
+    }
+    this.setState({customHeaders: newCustomHeaders});
+  }
+
+  renderCustomHeaders() {
+    return (
+      <bem.FormModal__item m='http-headers'>
+        <label>
+          {t('Custom HTTP Headers')}
+        </label>
+
+        {this.state.customHeaders.map((item, n) => {
+          return (
+            <bem.FormModal__item m='http-header-row' key={n}>
+              <input
+                type='text'
+                placeholder={t('Name')}
+                id={`headerName-${n}`}
+                name='headerName'
+                value={this.state.customHeaders[n].name}
+                data-index={n}
+                onChange={this.handleCustomHeaderChange}
+                onKeyPress={this.onCustomHeaderInputKeyPress}
+              />
+
+              <input
+                type='text'
+                placeholder={t('Value')}
+                id={`headerValue-${n}`}
+                name='headerValue'
+                value={this.state.customHeaders[n].value}
+                data-index={n}
+                onChange={this.handleCustomHeaderChange}
+                onKeyPress={this.onCustomHeaderInputKeyPress}
+              />
+
+              <button
+                className='http-header-row-remove'
+                data-index={n}
+                onClick={this.removeCustomHeaderRow}
+              >
+                <i className='k-icon k-icon-trash'/>
+              </button>
+            </bem.FormModal__item>
+          );
+        })}
+
+        <button
+          className='http-header-add'
+          onClick={this.addNewCustomHeaderRow}
+        >
+          <i className='k-icon k-icon-plus' />
+          {t('Add header')}
+        </button>
+      </bem.FormModal__item>
+    )
+  }
+
+  /*
+   * initialization
+   */
+
+  render() {
+    const isEditingExistingHook = Boolean(this.state.hookUid);
+
+    if (this.state.isLoadingHook) {
+      return (
+        <bem.Loading>
+          <bem.Loading__inner>
+            <i />
+            {t('loading...')}
+          </bem.Loading__inner>
+        </bem.Loading>
+      );
+    } else {
+      return (
+        <bem.FormModal__form onSubmit={this.onSubmit.bind(this)}>
+          <bem.FormModal__item m='wrapper'>
+            <bem.FormModal__item>
+              <TextBox
+                label={t('Name')}
+                type='text'
+                placeholder={t('Service Name')}
+                value={this.state.name}
+                errors={this.state.nameError}
+                onChange={this.handleNameChange.bind(this)}
+              />
+            </bem.FormModal__item>
+
+            <bem.FormModal__item>
+              <TextBox
+                label={t('Endpoint URL')}
+                type='text'
+                placeholder={t('https://')}
+                value={this.state.endpoint}
+                errors={this.state.endpointError}
+                onChange={this.handleEndpointChange.bind(this)}
+              />
+            </bem.FormModal__item>
+
+            <bem.FormModal__item>
+              <Checkbox
+                name='isActive'
+                id='active-checkbox'
+                onChange={this.handleActiveChange.bind(this)}
+                checked={this.state.isActive}
+                label={t('Enabled')}
+                errors={['test', 'secn']}
+              />
+            </bem.FormModal__item>
+
+            <bem.FormModal__item>
+              <label>{t('Type')}</label>
+
+              <bem.FormModal__item m='inline'>
+                <Radio
+                  value={EXPORT_TYPES.JSON}
+                  name='type'
+                  onChange={this.handleTypeRadioChange.bind(this)}
+                  checked={this.state.type === EXPORT_TYPES.JSON}
+                  label={t('JSON')}
+                />
+              </bem.FormModal__item>
+
+              <bem.FormModal__item m='inline'>
+                <Radio
+                  value={EXPORT_TYPES.XML}
+                  name='type'
+                  onChange={this.handleTypeRadioChange.bind(this)}
+                  checked={this.state.type === EXPORT_TYPES.XML}
+                  label={t('XML')}
+                />
+              </bem.FormModal__item>
+            </bem.FormModal__item>
+
+            <bem.FormModal__item>
+              <label htmlFor='rest-service-form--security'>
+                {t('Security')}
+              </label>
+
+              <Select
+                value={this.state.authLevel}
+                options={this.state.authOptions}
+                onChange={this.handleAuthTypeChange.bind(this)}
+                className='kobo-select'
+                classNamePrefix='kobo-select'
+                id='rest-service-form--security'
+                name='authLevel'
+                menuPlacement='auto'
+              />
+            </bem.FormModal__item>
+
+            {this.state.authLevel && this.state.authLevel.value === AUTH_OPTIONS.basic_auth.value &&
+              <bem.FormModal__item>
+                <TextBox
+                  label={t('Username')}
+                  type='text'
+                  value={this.state.authUsername}
+                  onChange={this.handleAuthUsernameChange.bind(this)}
+                />
+
+                <TextBox
+                  label={t('Password')}
+                  type='text'
+                  value={this.state.authPassword}
+                  onChange={this.handleAuthPasswordChange.bind(this)}
+                />
+              </bem.FormModal__item>
+            }
+
+            {this.renderCustomHeaders()}
+          </bem.FormModal__item>
+
+          <bem.Modal__footer>
+            <bem.Modal__footerButton
+              m='primary'
+              onClick={this.onSubmit}
+              disabled={this.state.isSubmitPending}
+            >
+              { isEditingExistingHook ? t('Save') : t('Create') }
+            </bem.Modal__footerButton>
+          </bem.Modal__footer>
+        </bem.FormModal__form>
+      );
+    }
+  }
+};
diff --git a/jsapp/js/components/RESTServices/RESTServicesList.es6 b/jsapp/js/components/RESTServices/RESTServicesList.es6
new file mode 100644
index 0000000000..cd2e36a08f
--- /dev/null
+++ b/jsapp/js/components/RESTServices/RESTServicesList.es6
@@ -0,0 +1,219 @@
+import React from 'react';
+import autoBind from 'react-autobind';
+import reactMixin from 'react-mixin';
+import Reflux from 'reflux';
+import alertify from 'alertifyjs';
+import stores from '../../stores';
+import actions from '../../actions';
+import {dataInterface} from '../../dataInterface';
+import bem from '../../bem';
+import {t} from '../../utils';
+import {MODAL_TYPES} from '../../constants';
+
+const RESTServicesSupportUrl = 'http://help.kobotoolbox.org/managing-your-project-s-data/rest-services';
+
+export default class RESTServicesList extends React.Component {
+  constructor(props){
+    super(props);
+    this.state = {
+      isLoadingHooks: true,
+      assetUid: props.assetUid,
+      hooks: []
+    };
+    autoBind(this);
+  }
+
+  componentDidMount() {
+    this.listenTo(
+      actions.hooks.getAll.completed,
+      this.onHooksUpdate
+    );
+
+    actions.hooks.getAll(
+      this.state.assetUid,
+      {
+        onComplete: (data) => {
+          this.setState({
+            isLoadingHooks: false,
+            hooks: data.results
+          });
+        },
+        onFail: (data) => {
+          this.setState({
+            isLoadingHooks: false
+          });
+          alertify.error(t('Could not load REST Services'));
+        }
+      }
+    );
+  }
+
+  onHooksUpdate(data) {
+    this.setState({
+      isLoadingHooks: false,
+      hooks: data.results
+    })
+  }
+
+  editHook(evt) {
+    stores.pageState.showModal({
+      assetUid: this.state.assetUid,
+      type: MODAL_TYPES.REST_SERVICES,
+      hookUid: evt.currentTarget.dataset.hookUid
+    });
+  }
+
+  deleteHookSafe(evt) {
+    const hookName = evt.currentTarget.dataset.hookName;
+    const hookUid = evt.currentTarget.dataset.hookUid;
+    if (this.state.assetUid) {
+      const dialog = alertify.dialog('confirm');
+      const message = t('You are about to delete ##target. This action cannot be undone.')
+        .replace('##target', `<strong>${hookName}</strong>`);
+      let dialogOptions = {
+        title: t(`Are you sure you want to delete ${hookName}?`),
+        message: message,
+        labels: { ok: t('Confirm'), cancel: t('Cancel') },
+        onok: () => {
+          actions.hooks.delete(this.state.assetUid, hookUid);
+        },
+        oncancel: () => {
+          dialog.destroy();
+        }
+      };
+      dialog.set(dialogOptions).show();
+    }
+  }
+
+  openNewRESTServiceModal() {
+    stores.pageState.showModal({
+      assetUid: this.state.assetUid,
+      // hookUid: not provided intentionally
+      type: MODAL_TYPES.REST_SERVICES
+    });
+  }
+
+  renderModalButton(additionalClassNames) {
+    return (
+      <button
+        className={`mdl-button mdl-button--raised mdl-button--colored ${additionalClassNames}`}
+        onClick={this.openNewRESTServiceModal}
+      >
+        {t('Register a New Service')}
+      </button>
+    );
+  }
+
+  renderEmptyView() {
+    return (
+      <bem.FormView m={'form-settings'} className='rest-services rest-services--empty'>
+        <bem.EmptyContent>
+          <bem.EmptyContent__icon className='k-icon-data-sync' />
+
+          <bem.EmptyContent__title>
+            {t("This project doesn't have any REST Services yet!")}
+          </bem.EmptyContent__title>
+
+          <bem.EmptyContent__message>
+            {t('You can use REST Services to automatically post submissions to a third-party application.')}
+            &nbsp;
+            <a href={RESTServicesSupportUrl} target='_blank'>{t('Learn more')}</a>
+          </bem.EmptyContent__message>
+
+          {this.renderModalButton('empty-content__button')}
+        </bem.EmptyContent>
+      </bem.FormView>
+    )
+  }
+
+  renderListView() {
+    return (
+      <bem.FormView m={'form-settings'} className='rest-services'>
+        <bem.FormView__cell m='rest-services-list'>
+          <header className='rest-services-list__header'>
+            <h2 className='rest-services-list__header-label'>
+              {t('REST Services: ##number##').replace('##number##', this.state.hooks.length)}
+            </h2>
+
+            <a
+              className='rest-services-list__header-help-link rest-services-list__header-right'
+              href={RESTServicesSupportUrl}
+              target='_blank'
+            >
+              <i className='k-icon k-icon-help' />
+              {t('Need help?')}
+            </a>
+          </header>
+
+          <bem.FormView__cell m={['box']}>
+            <bem.ServiceRow m='header'>
+              <bem.ServiceRow__column m='name'>{t('Service Name')}</bem.ServiceRow__column>
+              <bem.ServiceRow__column m='count'>{t('Count')}</bem.ServiceRow__column>
+              <bem.ServiceRow__column m='actions' />
+            </bem.ServiceRow>
+
+            {this.state.hooks.map((hook, n) => {
+              return (
+                <bem.ServiceRow key={hook.uid} m={hook.active ? 'active' : 'inactive'}>
+                  <bem.ServiceRow__column m='name'>
+                    <a href={`/#/forms/${this.state.assetUid}/settings/rest/${hook.uid}`}>{hook.name}</a>
+                  </bem.ServiceRow__column>
+
+                  <bem.ServiceRow__column m='count'>
+                    {hook.success_count + hook.pending_count + hook.failed_count}
+                    <span
+                      className='count-information-wrapper'
+                      data-tip={`${t('Success')} ${hook.success_count} · ${t('Pending')} ${hook.pending_count} · ${t('Failed')} ${hook.failed_count}`}
+                    >
+                      <i className='k-icon-help'/>
+                    </span>
+                  </bem.ServiceRow__column>
+
+                  <bem.ServiceRow__column m='actions'>
+                    <bem.ServiceRow__actionButton
+                      onClick={this.editHook}
+                      data-hook-uid={hook.uid}
+                      data-tip={t('Edit')}
+                    >
+                      <i className='k-icon-edit' />
+                    </bem.ServiceRow__actionButton>
+
+                    <bem.ServiceRow__actionButton
+                      onClick={this.deleteHookSafe.bind(this)}
+                      data-hook-name={hook.name}
+                      data-hook-uid={hook.uid}
+                      data-tip={t('Delete')}
+                    >
+                      <i className='k-icon-trash' />
+                    </bem.ServiceRow__actionButton>
+                  </bem.ServiceRow__column>
+                </bem.ServiceRow>
+              );
+            })}
+          </bem.FormView__cell>
+        </bem.FormView__cell>
+
+        {this.renderModalButton()}
+      </bem.FormView>
+    );
+  }
+
+  render() {
+    if (this.state.isLoadingHooks) {
+      return (
+        <bem.Loading>
+          <bem.Loading__inner>
+            <i />
+            {t('loading...')}
+          </bem.Loading__inner>
+        </bem.Loading>
+      )
+    } else if (this.state.hooks.length === 0) {
+      return this.renderEmptyView();
+    } else {
+      return this.renderListView();
+    }
+  }
+}
+
+reactMixin(RESTServicesList.prototype, Reflux.ListenerMixin);
diff --git a/jsapp/js/components/checkbox.es6 b/jsapp/js/components/checkbox.es6
new file mode 100644
index 0000000000..dc641b26c8
--- /dev/null
+++ b/jsapp/js/components/checkbox.es6
@@ -0,0 +1,51 @@
+import React from 'react';
+import autoBind from 'react-autobind';
+import bem from '../bem';
+
+/*
+Properties:
+- value <boolean>
+- onChange <function>: required
+- label <string>
+*/
+class Checkbox extends React.Component {
+  constructor(props){
+    if (typeof props.onChange !== 'function') {
+      throw new Error('onChange callback missing!')
+    }
+    super(props);
+    this.state = {
+      checked: props.checked
+    }
+    autoBind(this);
+  }
+
+  onChange(evt) {
+    this.setState({checked: evt.currentTarget.checked});
+    this.props.onChange(evt.currentTarget.checked);
+  }
+
+  render() {
+    return (
+      <bem.Checkbox>
+        <bem.Checkbox__wrapper>
+          <bem.Checkbox__input
+            type='checkbox'
+            name={this.props.name}
+            id={this.props.id}
+            onChange={this.onChange}
+            checked={this.state.checked}
+          />
+
+          {this.props.label &&
+            <bem.Checkbox__label htmlFor={this.props.id}>
+              {this.props.label}
+            </bem.Checkbox__label>
+          }
+        </bem.Checkbox__wrapper>
+      </bem.Checkbox>
+    )
+  }
+}
+
+export default Checkbox;
diff --git a/jsapp/js/components/formSubScreens.es6 b/jsapp/js/components/formSubScreens.es6
index b46886d9db..6e5a869631 100644
--- a/jsapp/js/components/formSubScreens.es6
+++ b/jsapp/js/components/formSubScreens.es6
@@ -22,6 +22,7 @@ import {ProjectDownloads} from '../components/formEditors';
 import {PROJECT_SETTINGS_CONTEXTS} from '../constants';
 
 import FormMap from '../components/map';
+import RESTServices from '../components/RESTServices';
 
 import {
   assign,
@@ -87,9 +88,6 @@ export class FormSubScreens extends React.Component {
         case `/forms/${this.state.uid}/data/map/${this.props.params.viewby}`:
           return <FormMap asset={this.state} viewby={this.props.params.viewby}/>;
           break;
-        // case `/forms/${this.state.uid}/settings/kobocat`:
-        //   iframeUrl = deployment__identifier+'/form_settings';
-        //   break;
         case `/forms/${this.state.uid}/data/downloads`:
           return this.renderProjectDownloads();
           break;
@@ -98,6 +96,21 @@ export class FormSubScreens extends React.Component {
             iframeUrl = deployment__identifier+'/form_settings';
           return this.renderSettingsEditor(iframeUrl);
           break;
+        case `/forms/${this.state.uid}/settings/media`:
+          iframeUrl = deployment__identifier+'/form_settings';
+          break;
+        case `/forms/${this.state.uid}/settings/sharing`:
+          return this.renderSharing();
+          break;
+        case `/forms/${this.state.uid}/settings/rest`:
+          return <RESTServices asset={this.state} />;
+          break;
+        case `/forms/${this.state.uid}/settings/rest/${this.props.params.hookUid}`:
+          return <RESTServices asset={this.state} hookUid={this.props.params.hookUid}/>;
+          break;
+        case `/forms/${this.state.uid}/settings/kobocat`:
+          iframeUrl = deployment__identifier+'/form_settings';
+          break;
         case `/forms/${this.state.uid}/reset`:
           return this.renderReset();
           break;
@@ -138,6 +151,13 @@ export class FormSubScreens extends React.Component {
       </DocumentTitle>
     );
   }
+  renderSharing() {
+    return (
+      <bem.FormView m='form-settings-sharing'>
+        <SharingForm uid={this.props.params.assetid} />
+      </bem.FormView>
+    );
+  }
   renderReset() {
     return (
       <bem.Loading>
diff --git a/jsapp/js/components/formViewTabs.es6 b/jsapp/js/components/formViewTabs.es6
index 6331b9535f..81d65db498 100644
--- a/jsapp/js/components/formViewTabs.es6
+++ b/jsapp/js/components/formViewTabs.es6
@@ -109,13 +109,15 @@ class FormViewTabs extends Reflux.Component {
       ];
     }
 
-    // if (this.state.asset && this.state.asset.deployment__active && this.isActiveRoute(`/forms/${this.state.assetid}/settings`)) {
-    //   sideTabs = [
-    //     {label: t('General settings'), icon: 'k-icon-information', path: `/forms/${this.state.assetid}/settings`},
-    //     {label: t('Sharing'), icon: 'k-icon-share', path: `/forms/${this.state.assetid}/settings/sharing`},
-    //     {label: t('Kobocat settings'), icon: 'k-icon-projects', path: `/forms/${this.state.assetid}/settings/kobocat`}
-    //   ];
-    // }
+    if (this.state.asset && this.state.asset.deployment__active && this.isActiveRoute(`/forms/${this.state.assetid}/settings`)) {
+       sideTabs = [
+          {label: t('General'), icon: 'k-icon-settings', path: `/forms/${this.state.assetid}/settings`},
+          {label: t('Media'), icon: 'k-icon-photo-gallery', path: `/forms/${this.state.assetid}/settings/media`},
+          {label: t('Sharing'), icon: 'k-icon-share', path: `/forms/${this.state.assetid}/settings/sharing`},
+          {label: t('REST Services'), icon: 'k-icon-data-sync', path: `/forms/${this.state.assetid}/settings/rest`},
+          {label: t('Kobocat (legacy)'), icon: 'k-icon-settings', path: `/forms/${this.state.assetid}/settings/kobocat`, className: 'is-edge'},
+        ];
+    }
 
     if (sideTabs.length > 0) {
       return (
diff --git a/jsapp/js/components/modal.es6 b/jsapp/js/components/modal.es6
index 5885e50f5a..02bc43e23d 100644
--- a/jsapp/js/components/modal.es6
+++ b/jsapp/js/components/modal.es6
@@ -19,6 +19,7 @@ import Submission from '../components/modalForms/submission';
 import TableColumnFilter from '../components/modalForms/tableColumnFilter';
 import TranslationSettings from '../components/modalForms/translationSettings';
 import TranslationTable from '../components/modalForms/translationTable';
+import RESTServicesForm from '../components/RESTServices/RESTServicesForm';
 
 class Modal extends React.Component {
   constructor(props) {
@@ -70,6 +71,14 @@ class Modal extends React.Component {
           modalClass: 'modal--large modal-submission',
           sid: this.props.params.sid
         });
+      break;
+
+      case MODAL_TYPES.REST_SERVICES:
+        if (this.props.params.hookUid) {
+          this.setState({title: t('Edit REST Service')});
+        } else {
+          this.setState({title: t('New REST Service')});
+        }
         break;
 
       case MODAL_TYPES.REPLACE_PROJECT:
@@ -239,6 +248,12 @@ class Modal extends React.Component {
                                  getColumnLabel={this.props.params.getColumnLabel}
                                  overrideLabelsAndGroups={this.props.params.overrideLabelsAndGroups} />
             }
+            { this.props.params.type == MODAL_TYPES.REST_SERVICES &&
+              <RESTServicesForm
+                assetUid={this.props.params.assetUid}
+                hookUid={this.props.params.hookUid}
+              />
+            }
             { this.props.params.type == MODAL_TYPES.FORM_LANGUAGES &&
               <TranslationSettings
                 asset={this.props.params.asset}
diff --git a/jsapp/js/components/radio.es6 b/jsapp/js/components/radio.es6
new file mode 100644
index 0000000000..5cdf87f663
--- /dev/null
+++ b/jsapp/js/components/radio.es6
@@ -0,0 +1,49 @@
+import React from 'react';
+import autoBind from 'react-autobind';
+import bem from '../bem';
+
+/*
+Properties:
+- label <string>
+- value <string>: required
+- checked <boolean>: initial value
+- onChange <function>: required
+*/
+class Radio extends React.Component {
+  constructor(props){
+    if (typeof props.onChange !== 'function') {
+      throw new Error('onChange callback missing!')
+    }
+    super(props);
+    autoBind(this);
+  }
+
+  onChange() {
+    this.props.onChange(this.props.name, this.props.value);
+  }
+
+  render() {
+    return (
+      <bem.Radio>
+        <bem.Radio__wrapper>
+          <bem.Radio__input
+            type='radio'
+            value={this.props.value}
+            name={this.props.name}
+            id={this.props.id}
+            onChange={this.onChange}
+            checked={this.props.checked}
+          />
+
+          {this.props.label &&
+            <bem.Radio__label htmlFor={this.props.id}>
+              {this.props.label}
+            </bem.Radio__label>
+          }
+        </bem.Radio__wrapper>
+      </bem.Radio>
+    )
+  }
+}
+
+export default Radio;
diff --git a/jsapp/js/constants.es6 b/jsapp/js/constants.es6
index 560fab4892..5ef0665a21 100644
--- a/jsapp/js/constants.es6
+++ b/jsapp/js/constants.es6
@@ -1,5 +1,11 @@
 import {t} from './utils';
 
+const HOOK_LOG_STATUSES = {
+  SUCCESS: 2,
+  PENDING: 1,
+  FAILED: 0
+}
+
 const MODAL_TYPES = {
   SHARING: 'sharing',
   UPLOADING_XLS: 'uploading-xls',
@@ -8,6 +14,7 @@ const MODAL_TYPES = {
   SUBMISSION: 'submission',
   REPLACE_PROJECT: 'replace-project',
   TABLE_COLUMNS: 'table-columns',
+  REST_SERVICES: 'rest-services',
   FORM_LANGUAGES: 'form-languages',
   FORM_TRANSLATIONS_TABLE: 'form-translation-table'
 }
@@ -75,5 +82,6 @@ export default {
   VALIDATION_STATUSES: VALIDATION_STATUSES,
   PROJECT_SETTINGS_CONTEXTS: PROJECT_SETTINGS_CONTEXTS,
   MODAL_TYPES: MODAL_TYPES,
-  ASSET_TYPES: ASSET_TYPES
+  ASSET_TYPES: ASSET_TYPES,
+  HOOK_LOG_STATUSES: HOOK_LOG_STATUSES
 };
diff --git a/jsapp/js/dataInterface.es6 b/jsapp/js/dataInterface.es6
index 28063b9778..cb94613e4a 100644
--- a/jsapp/js/dataInterface.es6
+++ b/jsapp/js/dataInterface.es6
@@ -72,6 +72,72 @@ var dataInterface;
         data: data
       });
     },
+
+    /*
+     * external services
+     */
+
+    getHooks(uid) {
+      return $ajax({
+        url: `${rootUrl}/assets/${uid}/hooks/`,
+        method: 'GET'
+      });
+    },
+    getHook(uid, hookUid) {
+      return $ajax({
+        url: `${rootUrl}/assets/${uid}/hooks/${hookUid}`,
+        method: 'GET'
+      });
+    },
+    addExternalService(uid, data) {
+      return $ajax({
+        url: `${rootUrl}/assets/${uid}/hooks/`,
+        method: 'POST',
+        data: JSON.stringify(data),
+        dataType: 'json',
+        contentType: 'application/json'
+      });
+    },
+    updateExternalService(uid, hookUid, data) {
+      return $ajax({
+        url: `${rootUrl}/assets/${uid}/hooks/${hookUid}`,
+        method: 'PATCH',
+        data: JSON.stringify(data),
+        dataType: 'json',
+        contentType: 'application/json'
+      });
+    },
+    deleteExternalService(uid, hookUid) {
+      return $ajax({
+        url: `${rootUrl}/assets/${uid}/hooks/${hookUid}`,
+        method: 'DELETE'
+      });
+    },
+    getHookLogs(uid, hookUid) {
+      return $ajax({
+        url: `/assets/${uid}/hooks/${hookUid}/logs/`,
+        method: 'GET'
+      })
+    },
+    getHookLog(uid, hookUid, lid) {
+      return $ajax({
+        url: `/assets/${uid}/hooks/${hookUid}/logs/${lid}/`,
+        method: 'GET'
+      })
+    },
+    retryExternalServiceLogs(uid, hookUid) {
+      return $ajax({
+        url: `/assets/${uid}/hooks/${hookUid}/retry/`,
+        method: 'PATCH'
+      })
+    },
+    retryExternalServiceLog(uid, hookUid, lid) {
+      return $ajax({
+        url: `/assets/${uid}/hooks/${hookUid}/logs/${lid}/retry/`,
+        method: 'PATCH'
+      })
+    },
+
     getReportData (data) {
       let identifierString;
       if (data.identifiers) {
diff --git a/jsapp/scss/components/_kobo.bem.ui.scss b/jsapp/scss/components/_kobo.bem.ui.scss
index affbdc36fb..d2b71973a1 100644
--- a/jsapp/scss/components/_kobo.bem.ui.scss
+++ b/jsapp/scss/components/_kobo.bem.ui.scss
@@ -482,6 +482,14 @@ iframe {
     margin-bottom: 15px;
   }
 
+  &.form-modal__item--inline {
+    display: inline-block;
+    &:not(:last-child) {
+      margin-bottom: 0;
+      margin-right: 20px;
+    }
+  }
+
   &--sector, &--country {
     width: 50%;
     float: left;
@@ -546,6 +554,12 @@ iframe {
     overflow: hidden;
     resize: none;
     height: auto;
+
+    &.questions {
+      height: 60px;
+      overflow: auto;
+      font-size: 13px;
+    }
   }
 
   input[type="checkbox"] {
@@ -672,15 +686,15 @@ span.svg-icon {
 // Checkboxes
 
 // Remove default checkbox
-[type="checkbox"]:not(:checked),
-[type="checkbox"]:checked {
+[type="checkbox"]:not(.checkbox .checkbox__input):not(:checked),
+[type="checkbox"]:not(.checkbox .checkbox__input):checked {
   position: absolute;
   left: -9999px;
   opacity: 0;
 }
 
 // Checkbox Styles
-[type="checkbox"] {
+[type="checkbox"]:not(.checkbox .checkbox__input) {
   + label {
     position: relative;
     padding-left: 35px;
diff --git a/jsapp/scss/components/_kobo.checkbox-and-radio.scss b/jsapp/scss/components/_kobo.checkbox-and-radio.scss
new file mode 100644
index 0000000000..e9f1a906ae
--- /dev/null
+++ b/jsapp/scss/components/_kobo.checkbox-and-radio.scss
@@ -0,0 +1,100 @@
+.radio,
+.checkbox {
+  .radio__wrapper,
+  .checkbox__wrapper {
+    color: $black;
+    font-size: 14px;
+    padding: 4px 0;
+    cursor: pointer;
+  }
+
+  .radio__input,
+  .checkbox__input,
+  .radio__label,
+  .checkbox__label {
+    display: inline-block;
+    vertical-align: top;
+  }
+
+  .radio__label,
+  .checkbox__label {
+    max-width: calc(100% - 28px);
+  }
+
+  .radio__input + .radio__label,
+  .checkbox__input + .checkbox__label {
+    margin-left: 8px;
+  }
+
+  .radio__input {
+    border-radius: 50%;
+    &::after {
+      content: "";
+      top: 4px;
+      left: 4px;
+      border-radius: 50%;
+      width: 10px;
+      height: 10px;
+      background-color: $cool-blue;
+    }
+  }
+
+  .checkbox__input {
+    border-radius: 2px;
+    &::after {
+      content: "✓";
+      top: 0;
+      left: 0;
+      width: 18px;
+      height: 18px;
+      color: $white;
+      background-color: $cool-blue;
+      text-align: center;
+      line-height: 18px;
+      font-size: 18px;
+    }
+  }
+
+  .radio__input,
+  .checkbox__input {
+    appearance: none;
+    position: relative;
+    margin: 0;
+    border: 1px solid $cool-gray;
+    width: 20px;
+    height: 20px;
+    outline: 0;
+    background-color: transparent;
+    color: $cool-gray;
+    cursor: pointer;
+
+    &::after {
+      display: block;
+      position: absolute;
+      opacity: 0;
+    }
+
+    &:checked {
+      border-color: $cool-blue;
+
+      &::after {opacity: 1;}
+    }
+
+    &[disabled] {
+      pointer-events: none;
+      opacity: 0.5;
+    }
+  }
+
+  &:hover .radio__input:not([disabled]),
+  &:hover .checkbox__input:not([disabled]) {
+    &:checked::after { opacity: 0.8; }
+    &:not(:checked)::after { opacity: 0.1; }
+  }
+
+  &:active .radio__input:not([disabled]),
+  &:active .checkbox__input:not([disabled]) {
+    &:checked::after { opacity: 0.6; }
+    &:not(:checked)::after { opacity: 0.3; }
+  }
+}
diff --git a/jsapp/scss/components/_kobo.empty-content.scss b/jsapp/scss/components/_kobo.empty-content.scss
new file mode 100644
index 0000000000..a8a78f7c09
--- /dev/null
+++ b/jsapp/scss/components/_kobo.empty-content.scss
@@ -0,0 +1,25 @@
+.empty-content {
+  text-align: center;
+  padding: 0 30px 30px;
+}
+
+.empty-content__icon {
+  display: block;
+  font-size: 180px;
+  opacity: 0.25;
+}
+
+.empty-content__title {
+  font-weight: 400;
+  font-size: 20px;
+  margin: 0;
+}
+
+.empty-content__message {
+  margin: 1em 0 0;
+}
+
+.empty-content__button {
+  display: block;
+  margin: 2em auto 0;
+}
diff --git a/jsapp/scss/components/_kobo.form-view.scss b/jsapp/scss/components/_kobo.form-view.scss
index f81cef0d42..2075d98fa4 100644
--- a/jsapp/scss/components/_kobo.form-view.scss
+++ b/jsapp/scss/components/_kobo.form-view.scss
@@ -476,8 +476,6 @@ $z-form-view-fullscreen: 101;
 }
 
 .form-view.form-view--form-settings {
-  overflow: initial;
-
   .form-modal__form {
     height: 100%;
 
@@ -492,6 +490,15 @@ $z-form-view-fullscreen: 101;
   }
 }
 
+.form-view.form-view--form-settings-sharing {
+  .form-modal {
+    background: white;
+    padding: 40px;
+    height: 100%;
+    overflow: auto;
+  }
+}
+
 .form-view.form-view--form-data-downloads {
   .form-modal__item {
     &:last-child {
@@ -636,6 +643,7 @@ $z-form-view-fullscreen: 101;
       padding: 3px;
       padding-left: 1px;
       font-size: 10px;
+      line-height: 1.5em;
       text-align: center;
       display: block;
       letter-spacing: -0.05em;
diff --git a/jsapp/scss/components/_kobo.modal.scss b/jsapp/scss/components/_kobo.modal.scss
index 6ef69550d8..18ca309bed 100644
--- a/jsapp/scss/components/_kobo.modal.scss
+++ b/jsapp/scss/components/_kobo.modal.scss
@@ -510,6 +510,52 @@ $z-modal-x: 10;
   }
 }
 
+.form-modal__item--http-headers {
+  .form-modal__item--http-header-row {
+    margin-top: 10px;
+
+    input {
+      width: calc(50% - 20px);
+      background-color: rgba($black, 0.05);
+      padding-left: 5px;
+      padding-right: 5px;
+
+      &:not(:first-child) {
+        margin-left: 10px;
+      }
+    }
+  }
+
+  .http-header-add,
+  .http-header-row-remove {
+    height: 30px;
+    min-height: 30px;
+    line-height: 30px;
+
+    .k-icon {
+      font-size: 1.5em;
+      vertical-align: middle;
+    }
+  }
+
+  .http-header-add {
+    @extend .mdl-button, .mdl-button--raised, .mdl-button--colored;
+    background: $cool-gray;
+    vertical-align: middle;
+    padding: 0 12px 0 6px;
+
+    &:hover {background: darken($cool-gray, 10%);}
+  }
+
+  .http-header-row-remove {
+    @extend .mdl-button, .mdl-button--icon;
+    width: 30px;
+    vertical-align: top;
+    padding: 0;
+    &:hover {color: $cool-red;}
+  }
+}
+
 .form-modal--translation-settings {
   @media (min-width: 600px) {
     min-width: 500px;
diff --git a/jsapp/scss/components/_kobo.rest-services.scss b/jsapp/scss/components/_kobo.rest-services.scss
new file mode 100644
index 0000000000..d58b3b149c
--- /dev/null
+++ b/jsapp/scss/components/_kobo.rest-services.scss
@@ -0,0 +1,61 @@
+// RESTServices custom overrides
+
+.rest-services {
+  display: flex;
+  flex-direction: column;
+
+  // centers empty content message
+  &.rest-services--empty {
+    align-items: center;
+    justify-items: center;
+  }
+
+  .form-view__cell--rest-services-list {flex: 1;}
+
+  > button {
+    display: block;
+    align-self: flex-end;
+    margin-top: 30px;
+  }
+
+  .rest-services-list__header::after {
+    content: '';
+    display: table;
+    clear: both;
+  }
+
+  .rest-services-list__header-label {
+    display: inline-block;
+    font-size: inherit;
+    font-weight: 600;
+
+    &.rest-services-list__header-label--big {
+      display: block;
+      font-size: 1.5em;
+    }
+  }
+
+  .rest-services-list__header-label,
+  .rest-services-list__header-help-link {
+    margin: 0;
+    line-height: 20px;
+    padding: 10px 0;
+    min-height: 36px;
+
+    i {
+      font-size: 20px;
+      vertical-align: top;
+      display: inline-block;
+    }
+  }
+
+  .rest-services-list__header-right {float: right;}
+
+  .rest-services-list__header-back-button {
+    @extend .mdl-button, .mdl-button--icon;
+
+    i {
+      vertical-align: middle;
+    }
+  }
+}
diff --git a/jsapp/scss/components/_kobo.service-row.scss b/jsapp/scss/components/_kobo.service-row.scss
new file mode 100644
index 0000000000..0177271de5
--- /dev/null
+++ b/jsapp/scss/components/_kobo.service-row.scss
@@ -0,0 +1,143 @@
+$s-service-row-action-button: 36px;
+$s-service-row-leading: 18px;
+$s-service-row-column-spacing: ($s-service-row-action-button - $s-service-row-leading) * 0.5;
+
+.service-row {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  min-height: $s-service-row-action-button;
+  box-sizing: content-box;
+  line-height: $s-service-row-leading;
+
+  &:not(:last-of-type) {
+    border-bottom: 1px solid $divider-color;
+  }
+
+  &:not(.service-row--header):hover {
+    background-color: $cool-whitegray;
+  }
+
+  &.service-row--header {
+    font-weight: 600;
+    border-bottom-width: 2px;
+  }
+
+  &.service-row--active {
+    color: $cool-darkgray;
+  }
+
+  &.service-row--inactive {
+    color: $cool-silver;
+  }
+}
+
+.service-row__column {
+  &.service-row__column--name {
+    flex: 6;
+    padding: 0 $s-service-row-column-spacing;
+
+    .service-row--header & {padding: $s-service-row-column-spacing;}
+
+    a {
+      color: inherit;
+      display: block;
+      padding: $s-service-row-column-spacing 0;
+
+      &:hover {color: $cool-charcoal;}
+    }
+  }
+
+  &.service-row__column--count {
+    flex: 1;
+    padding: $s-service-row-column-spacing;
+    line-height: 18px;
+
+    .count-information-wrapper {
+      display: inline-block;
+      vertical-align: bottom;
+      font-size: 36px;
+
+      &[data-tip]::before,
+      &[data-tip]::after {
+        // to align with action buttons
+        margin-top: 9px;
+      }
+
+      i {
+        color: inherit;
+        vertical-align: inherit;
+        line-height: inherit;
+
+        &::before {
+          vertical-align: inherit;
+          line-height: inherit;
+        }
+      }
+    }
+  }
+
+
+  &.service-row__column--actions {
+    flex: 1;
+    padding: 0 $s-service-row-column-spacing;
+    box-sizing: content-box;
+    white-space: nowrap;
+  }
+
+  &.service-row__column--submission {
+    flex: 3;
+    padding: $s-service-row-column-spacing;
+  }
+
+  &.service-row__column--status {
+    flex: 1;
+    padding: 0 $s-service-row-column-spacing;
+    line-height: $s-service-row-action-button;
+    white-space: nowrap;
+  }
+
+  &.service-row__column--date {
+    flex: 1;
+    padding: $s-service-row-column-spacing;
+  }
+
+  &.service-row__column--success {
+    color: $cool-gray;
+  }
+
+  &.service-row__column--pending {
+    color: $cool-green;
+  }
+
+  &.service-row__column--failed {
+    color: $cool-red;
+  }
+}
+
+.service-row__action-button {
+  appearance: none;
+  border: 0;
+  padding: 0;
+  width: $s-service-row-action-button;
+  height: $s-service-row-action-button;
+  font-size: $s-service-row-action-button;
+  color: inherit;
+  cursor: pointer;
+  background: transparent;
+  display: inline-block;
+  vertical-align: top;
+
+  &:first-of-type {
+    margin-left: 12px;
+  }
+
+  &[disabled] {
+    opacity: 0.5;
+    pointer-events: none;
+  }
+
+  &:hover {
+    color: $cool-blue;
+  }
+}
diff --git a/jsapp/scss/libs/_mdl.buttons.scss b/jsapp/scss/libs/_mdl.buttons.scss
index cb82e9c9e9..cfc5f04b56 100644
--- a/jsapp/scss/libs/_mdl.buttons.scss
+++ b/jsapp/scss/libs/_mdl.buttons.scss
@@ -8,6 +8,7 @@
   font-size: 14px;
   letter-spacing: 0;
   height: 40px;
+  min-height: 40px;
   line-height: 40px;
   padding: 0px 24px;
   margin: 0;
diff --git a/jsapp/scss/libs/_mdl.scss b/jsapp/scss/libs/_mdl.scss
index ddbdf19015..c9dad19095 100644
--- a/jsapp/scss/libs/_mdl.scss
+++ b/jsapp/scss/libs/_mdl.scss
@@ -1,6 +1,7 @@
 // Theming variables, mixins and includes
 
 $black: #414453;
+$white: #fff;
 $cool-charcoal: lighten($black, 10%);
 $cool-darkgray: lighten($black, 20%);
 $cool-gray: lighten($black, 30%);
diff --git a/jsapp/scss/main.scss b/jsapp/scss/main.scss
index 1a38f6990b..352c5db83d 100644
--- a/jsapp/scss/main.scss
+++ b/jsapp/scss/main.scss
@@ -12,6 +12,7 @@
 @import "./libs/react-tagsinput";
 
 @import "./components/kobo.bem.ui";
+@import "./components/kobo.checkbox-and-radio";
 @import "./components/kobo.modal";
 @import "./components/kobo.tooltips";
 @import "./components/kobo.navigation";
@@ -32,6 +33,9 @@
 @import "./components/kobo.account-settings";
 @import "./components/kobo.sharing-modal";
 @import "./components/kobo.map";
+@import "./components/kobo.rest-services";
+@import "./components/kobo.service-row";
+@import "./components/kobo.empty-content";
 @import "./components/kobo.map.marker-colors";
 @import "./components/kobo.templates-list";
 @import "./components/kobo.text-box";
diff --git a/kobo/apps/hook/__init__.py b/kobo/apps/hook/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/kobo/apps/hook/constants.py b/kobo/apps/hook/constants.py
new file mode 100644
index 0000000000..d078023cc5
--- /dev/null
+++ b/kobo/apps/hook/constants.py
@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+HOOK_LOG_FAILED = 0
+HOOK_LOG_PENDING = 1
+HOOK_LOG_SUCCESS = 2
+
+KOBO_INTERNAL_ERROR_STATUS_CODE = None
\ No newline at end of file
diff --git a/kobo/apps/hook/migrations/0001_tables_creation.py b/kobo/apps/hook/migrations/0001_tables_creation.py
new file mode 100644
index 0000000000..d9cb48c715
--- /dev/null
+++ b/kobo/apps/hook/migrations/0001_tables_creation.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.utils.timezone
+import jsonbfield.fields
+import kpi.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('kpi', '0022_assetfile'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Hook',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('uid', kpi.fields.KpiUidField(uid_prefix=b'h')),
+                ('name', models.CharField(max_length=255)),
+                ('endpoint', models.CharField(max_length=500)),
+                ('active', models.BooleanField(default=True)),
+                ('export_type', models.CharField(default=b'json', max_length=10, choices=[(b'xml', b'xml'), (b'json', b'json')])),
+                ('auth_level', models.CharField(default=b'no_auth', max_length=10, choices=[(b'no_auth', b'no_auth'), (b'basic_auth', b'basic_auth')])),
+                ('settings', jsonbfield.fields.JSONField(default=dict)),
+                ('date_created', models.DateTimeField(default=django.utils.timezone.now)),
+                ('date_modified', models.DateTimeField(default=django.utils.timezone.now)),
+                ('asset', models.ForeignKey(related_name='hooks', to='kpi.Asset')),
+            ],
+            options={
+                'ordering': ['name'],
+            },
+        ),
+        migrations.CreateModel(
+            name='HookLog',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('uid', kpi.fields.KpiUidField(uid_prefix=b'hl')),
+                ('instance_id', models.IntegerField(default=0, db_index=True)),
+                ('tries', models.PositiveSmallIntegerField(default=0)),
+                ('status', models.PositiveSmallIntegerField(default=1)),
+                ('status_code', models.IntegerField(default=None, null=True, blank=True)),
+                ('message', models.TextField(default=b'')),
+                ('date_created', models.DateTimeField(auto_now_add=True)),
+                ('date_modified', models.DateTimeField(auto_now_add=True)),
+                ('hook', models.ForeignKey(related_name='logs', to='hook.Hook')),
+            ],
+            options={
+                'ordering': ['-date_created'],
+            },
+        ),
+    ]
diff --git a/kobo/apps/hook/migrations/__init__.py b/kobo/apps/hook/migrations/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/kobo/apps/hook/models/__init__.py b/kobo/apps/hook/models/__init__.py
new file mode 100644
index 0000000000..2f369ad1a6
--- /dev/null
+++ b/kobo/apps/hook/models/__init__.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from .hook import Hook
+from .hook_log import HookLog
\ No newline at end of file
diff --git a/kobo/apps/hook/models/hook.py b/kobo/apps/hook/models/hook.py
new file mode 100644
index 0000000000..e8897d6578
--- /dev/null
+++ b/kobo/apps/hook/models/hook.py
@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+from importlib import import_module
+
+from django.db import models
+from django.utils import timezone
+from jsonbfield.fields import JSONField as JSONBField
+
+from ..constants import HOOK_LOG_PENDING, HOOK_LOG_FAILED, HOOK_LOG_SUCCESS
+from kpi.fields import KpiUidField
+
+
+class Hook(models.Model):
+
+    # Export types
+    XML = "xml"
+    JSON = "json"
+
+    # Authentication levels
+    NO_AUTH = "no_auth"
+    BASIC_AUTH = "basic_auth"
+
+    # Export types list
+    EXPORT_TYPE_CHOICES = (
+        (XML, XML),
+        (JSON, JSON)
+    )
+
+    # Authentication levels list
+    AUTHENTICATION_LEVEL_CHOICES = (
+        (NO_AUTH, NO_AUTH),
+        (BASIC_AUTH, BASIC_AUTH)
+    )
+
+    asset = models.ForeignKey("kpi.Asset", related_name="hooks", on_delete=models.CASCADE)
+    uid = KpiUidField(uid_prefix="h")
+    name = models.CharField(max_length=255, blank=False)
+    endpoint = models.CharField(max_length=500, blank=False)
+    active = models.BooleanField(default=True)
+    export_type = models.CharField(choices=EXPORT_TYPE_CHOICES, default=JSON, max_length=10)
+    auth_level = models.CharField(choices=AUTHENTICATION_LEVEL_CHOICES, default=NO_AUTH, max_length=10)
+    settings = JSONBField(default=dict)
+    date_created = models.DateTimeField(default=timezone.now)
+    date_modified = models.DateTimeField(default=timezone.now)
+
+    class Meta:
+        ordering = ["name"]
+
+    def __init__(self, *args, **kwargs):
+        self.__totals = {}
+        return super(Hook, self).__init__(*args, **kwargs)
+
+    def save(self, *args, **kwargs):
+        # Update date_modified each time object is saved
+        self.date_modified = timezone.now()
+        super(Hook, self).save(*args, **kwargs)
+
+    def __unicode__(self):
+        return u"%s:%s - %s" % (self.asset, self.name, self.endpoint)
+
+    def get_service_definition(self):
+        mod = import_module("kobo.apps.hook.services.service_{}".format(self.export_type))
+        return getattr(mod, "ServiceDefinition")
+
+    @property
+    def success_count(self):
+        if not self.__totals:
+            self._get_totals()
+        return self.__totals.get(HOOK_LOG_SUCCESS)
+
+    @property
+    def failed_count(self):
+        if not self.__totals:
+            self._get_totals()
+        return self.__totals.get(HOOK_LOG_FAILED)
+
+    @property
+    def pending_count(self):
+        if not self.__totals:
+            self._get_totals()
+        return self.__totals.get(HOOK_LOG_PENDING)
+
+    def _get_totals(self):
+        # TODO add some cache
+        queryset = self.logs.values("status").annotate(values_count=models.Count("status"))
+        queryset.query.clear_ordering(True)
+
+        # Initialize totals
+        self.__totals = {
+            HOOK_LOG_SUCCESS: 0,
+            HOOK_LOG_FAILED: 0,
+            HOOK_LOG_PENDING: 0
+        }
+        for record in queryset:
+            self.__totals[record.get("status")] = record.get("values_count")
+
+    def reset_totals(self):
+        # TODO remove cache when it's enabled
+        self.__totals = {}
\ No newline at end of file
diff --git a/kobo/apps/hook/models/hook_log.py b/kobo/apps/hook/models/hook_log.py
new file mode 100644
index 0000000000..7e69f7c9dd
--- /dev/null
+++ b/kobo/apps/hook/models/hook_log.py
@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+from datetime import datetime, timedelta
+from importlib import import_module
+
+import constance
+from django.db import models
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from jsonbfield.fields import JSONField as JSONBField
+import requests
+from rest_framework import status
+from rest_framework.reverse import reverse
+
+from ..constants import HOOK_LOG_PENDING, HOOK_LOG_FAILED, HOOK_LOG_SUCCESS, KOBO_INTERNAL_ERROR_STATUS_CODE
+from kpi.fields import KpiUidField
+from kpi.utils.log import logging
+
+
+class HookLog(models.Model):
+
+    hook = models.ForeignKey("Hook", related_name="logs", on_delete=models.CASCADE)
+    uid = KpiUidField(uid_prefix="hl")
+    instance_id = models.IntegerField(default=0, db_index=True)  # `kc.logger.Instance.id`.
+    tries = models.PositiveSmallIntegerField(default=0)
+    status = models.PositiveSmallIntegerField(default=HOOK_LOG_PENDING)  # Could use status_code, but will speed-up queries.
+    status_code = models.IntegerField(default=KOBO_INTERNAL_ERROR_STATUS_CODE, null=True, blank=True)
+    message = models.TextField(default="")
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ["-date_created"]
+
+    def can_retry(self):
+        """
+        Returns whether instance can be resent to external endpoint.
+        Notice: even if returns false, `self.retry()` can be triggered.
+
+        :return: bool
+        """
+        if self.hook.active:
+            seconds = HookLog.get_elapsed_seconds(constance.config.HOOK_MAX_RETRIES)
+            threshold = timezone.now() - timedelta(seconds=seconds)
+            # We can retry only if system has already tried 3 times.
+            # If log is still pending after 3 times, there was an issue, we allow the retry
+            return self.status == HOOK_LOG_FAILED or \
+                (self.date_modified < threshold and self.status == HOOK_LOG_PENDING)
+
+        return False
+
+    def change_status(self, status=HOOK_LOG_PENDING, message=None, status_code=None):
+        self.status = status
+
+        if message:
+            self.message = message
+
+        if status_code:
+            self.status_code = status_code
+
+        self.save(reset_status=True)
+
+    @staticmethod
+    def get_elapsed_seconds(retries_count):
+        """
+        Calculate number of elapsed seconds since first try
+        :param retries_count: int.
+        :return: int. Number of seconds
+        """
+        # We need to sum all seconds between each retry
+        seconds = 0
+        for retries_count in range(retries_count):
+            seconds += HookLog.get_remaining_seconds(retries_count)  # Range is zero-indexed
+
+        return seconds
+
+    @staticmethod
+    def get_remaining_seconds(retries_count):
+        """
+        Calculate number of remaining seconds before next retry
+        :param retries_count: int.
+        :return: int. Number of seconds
+        """
+        return 60 * (10 ** retries_count)
+
+    def retry(self):
+        """
+        Retries to send data to external service
+        :return: boolean
+        """
+        try:
+            ServiceDefinition = self.hook.get_service_definition()
+            service_definition = ServiceDefinition(self.hook, self.instance_id)
+            service_definition.send()
+            self.refresh_from_db()
+        except Exception as e:
+            logging.error("HookLog.retry - {}".format(str(e)), exc_info=True)
+            self.change_status(HOOK_LOG_FAILED)
+            return False
+
+        return True
+
+    def save(self, *args, **kwargs):
+        # Update date_modified each time object is saved
+        self.date_modified = timezone.now()
+        # We don't want to alter tries when we only change the status
+        if kwargs.pop("reset_status", False) is False:
+            self.tries += 1
+            self.hook.reset_totals()
+        super(HookLog, self).save(*args, **kwargs)
+
+    @property
+    def status_str(self):
+        if self.status == HOOK_LOG_PENDING:
+            return "Pending"
+        elif self.status == HOOK_LOG_FAILED:
+            return "Failed"
+        elif self.status == HOOK_LOG_SUCCESS:
+            return "Success"
+
+    def __unicode__(self):
+        return "<HookLog {uid}>".format(uid=self.uid)
\ No newline at end of file
diff --git a/kobo/apps/hook/models/service_definition_interface.py b/kobo/apps/hook/models/service_definition_interface.py
new file mode 100644
index 0000000000..632d6425b5
--- /dev/null
+++ b/kobo/apps/hook/models/service_definition_interface.py
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from abc import ABCMeta, abstractmethod
+import json
+import os
+import re
+
+import constance
+import requests
+from rest_framework import status
+
+from ..constants import HOOK_LOG_SUCCESS, HOOK_LOG_FAILED, KOBO_INTERNAL_ERROR_STATUS_CODE
+from .hook import Hook
+from .hook_log import HookLog
+from kpi.utils.log import logging
+
+
+class ServiceDefinitionInterface(object):
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self, hook, instance_id):
+        self._hook = hook
+        self._instance_id = instance_id
+        self._data = self._get_data()
+
+    def _get_data(self):
+        """
+        Retrieves data from deployment backend of the asset.
+        """
+        try:
+            return self._hook.asset.deployment.get_submission(self._instance_id, self._hook.export_type)
+        except Exception as e:
+            logging.error("service_json.ServiceDefinition._get_data - Hook #{} - Data #{} - {}".format(
+                self._hook.uid, self._instance_id, str(e)), exc_info=True)
+        return None
+
+    @abstractmethod
+    def _prepare_request_kwargs(self):
+        """
+        Prepares params to pass to `Requests.post` in `send` method.
+        It defines headers and data.
+
+        For example:
+            {
+                "headers": {"Content-Type": "application/json"},
+                "json": self._data
+            }
+        :return: dict
+        """
+        pass
+
+    def send(self):
+        """
+        Sends data to external endpoint
+        :return: bool
+        """
+
+        success = False
+        response = None  # Need to declare response before requests.post assignment in case of RequestException
+        if self._data:
+            try:
+                request_kwargs = self._prepare_request_kwargs()
+
+                # Add custom headers
+                request_kwargs.get("headers").update(self._hook.settings.get("custom_headers", {}))
+
+                # Add user agent
+                public_domain = "- {} ".format(os.getenv("PUBLIC_DOMAIN_NAME"))\
+                    if os.getenv("PUBLIC_DOMAIN_NAME") else ""
+                request_kwargs.get("headers").update({
+                    "User-Agent": "KoBoToolbox external service {}#{}".format(
+                        public_domain,
+                        self._hook.uid)
+                })
+
+                # If the request needs basic authentication with username & password,
+                # let's provide them
+                if self._hook.auth_level == Hook.BASIC_AUTH:
+                    request_kwargs.update({
+                        "auth": (self._hook.settings.get("username"),
+                                 self._hook.settings.get("password"))
+                    })
+                response = requests.post(self._hook.endpoint, timeout=30, **request_kwargs)
+                response.raise_for_status()
+                self.save_log(response.status_code, response.text, True)
+                success = True
+            except requests.exceptions.RequestException as e:
+                # If request fails to communicate with remote server. Exception is raised before
+                # request.post can return something. Thus, response equals None
+                status_code = KOBO_INTERNAL_ERROR_STATUS_CODE
+                text = str(e)
+                if response is not None:
+                    text = response.text
+                    status_code = response.status_code
+                self.save_log(status_code, text)
+
+            except Exception as e:
+                logging.error("service_json.ServiceDefinition.send - Hook #{} - Data #{} - {}".format(
+                    self._hook.uid, self._instance_id, str(e)), exc_info=True)
+                self.save_log(
+                    KOBO_INTERNAL_ERROR_STATUS_CODE,
+                    "An error occurred when sending data to external endpoint")
+        else:
+            self.save_log(
+                KOBO_INTERNAL_ERROR_STATUS_CODE,
+                "No data available")
+
+        return success
+
+    def save_log(self, status_code, message, success=False):
+        """
+        Updates/creates log entry
+
+        :param success: bool.
+        :param status_code: int. HTTP status code
+        :param message: str.
+        """
+        fields = {
+            "hook": self._hook,
+            "instance_id": self._instance_id
+        }
+        try:
+            # Try to load the log with a multiple field FK because
+            # we don't know the log `uid` in this context, but we do know
+            # its `hook` FK and its `instance.uuid
+            log = HookLog.objects.get(**fields)
+        except HookLog.DoesNotExist:
+            log = HookLog(**fields)
+
+        if success:
+            log.status = HOOK_LOG_SUCCESS
+        elif log.tries >= constance.config.HOOK_MAX_RETRIES:
+            log.status = HOOK_LOG_FAILED
+
+        log.status_code = status_code
+
+        # We want to clean up HTML, so first, we try to create a json object.
+        # In case of failure, it should be HTML (or plaintext), we can remove tags
+        try:
+            json.loads(message)
+        except ValueError as e:
+            message = re.sub(r"<[^>]*>", " ", message).strip()
+
+        log.message = message
+
+        try:
+            log.save()
+        except Exception as e:
+            logging.error("ServiceDefinitionInterface.save_log - {}".format(str(e)), exc_info=True)
diff --git a/kobo/apps/hook/serializers/__init__.py b/kobo/apps/hook/serializers/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/kobo/apps/hook/serializers/hook.py b/kobo/apps/hook/serializers/hook.py
new file mode 100644
index 0000000000..a1d8a5000c
--- /dev/null
+++ b/kobo/apps/hook/serializers/hook.py
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+
+from ..models.hook import Hook
+
+
+class HookSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Hook
+        fields = ("url", "logs_url", "asset", "uid", "name", "endpoint", "active", "export_type",
+                  "auth_level", "success_count", "failed_count", "pending_count", "settings",
+                  "date_modified")
+
+        read_only_fields = ("asset", "uid", "date_modified", "success_count", "failed_count", "pending_count")
+
+    url = serializers.SerializerMethodField()
+    logs_url = serializers.SerializerMethodField()
+
+    def get_url(self, hook):
+        return reverse("hook-detail", args=(hook.asset.uid, hook.uid),
+                       request=self.context.get("request", None))
+
+    def get_logs_url(self, hook):
+        return reverse("hook-log-list", args=(hook.asset.uid, hook.uid),
+                       request=self.context.get("request", None))
\ No newline at end of file
diff --git a/kobo/apps/hook/serializers/hook_log.py b/kobo/apps/hook/serializers/hook_log.py
new file mode 100644
index 0000000000..8587a81870
--- /dev/null
+++ b/kobo/apps/hook/serializers/hook_log.py
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+
+from ..models.hook_log import HookLog
+
+
+class HookLogSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = HookLog
+        fields = ("url", "uid", "tries", "status", "status_str", "status_code",
+                  "message", "date_modified")
+
+        read_only_fields = ("uid", "tries", "status", "status_str", "status_code", "message", "date_modified")
+
+    url = serializers.SerializerMethodField()
+
+    def get_url(self, hook_log):
+        hook = hook_log.hook
+        return reverse("hook-log-detail", args=(hook.asset.uid, hook.uid, hook_log.uid),
+                       request=self.context.get("request", None))
diff --git a/kobo/apps/hook/services/__init__.py b/kobo/apps/hook/services/__init__.py
new file mode 100644
index 0000000000..40a96afc6f
--- /dev/null
+++ b/kobo/apps/hook/services/__init__.py
@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-
diff --git a/kobo/apps/hook/services/service_json.py b/kobo/apps/hook/services/service_json.py
new file mode 100644
index 0000000000..c3add9756d
--- /dev/null
+++ b/kobo/apps/hook/services/service_json.py
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import json
+
+from ..models.service_definition_interface import ServiceDefinitionInterface
+
+
+class ServiceDefinition(ServiceDefinitionInterface):
+    id = u"json"
+
+    def _prepare_request_kwargs(self):
+        return {
+            "headers": {"Content-Type": "application/json"},
+            "json": self._data
+        }
\ No newline at end of file
diff --git a/kobo/apps/hook/services/service_xml.py b/kobo/apps/hook/services/service_xml.py
new file mode 100644
index 0000000000..e5ecc76ffd
--- /dev/null
+++ b/kobo/apps/hook/services/service_xml.py
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import requests
+
+from ..models.service_definition_interface import ServiceDefinitionInterface
+
+
+class ServiceDefinition(ServiceDefinitionInterface):
+    id = u"xml"
+
+    def _prepare_request_kwargs(self):
+        return {
+            "headers": {"Content-Type": "application/xml"},
+            "data": self._data
+        }
+
diff --git a/kobo/apps/hook/tasks.py b/kobo/apps/hook/tasks.py
new file mode 100644
index 0000000000..dbc8f75228
--- /dev/null
+++ b/kobo/apps/hook/tasks.py
@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+import time
+
+from celery import shared_task
+import constance
+
+from .models import Hook, HookLog
+
+
+@shared_task(bind=True)
+def service_definition_task(self, hook_id, instance_id):
+    """
+    Tries to send data to the endpoint of the hook
+    It retries n times (n = `constance.config.HOOK_MAX_RETRIES`)
+
+    - after 1 minutes,
+    - after 10 minutes,
+    - after 100 minutes
+    etc ...
+
+    :param self: Celery.Task.
+    :param hook_id: int. Hook PK
+    :param instance_id: int. Instance PK
+    """
+    hook = Hook.objects.get(id=hook_id)
+    # Use camelcase (even if it's not PEP-8 compliant)
+    # because variable represents the class, not the instance.
+    ServiceDefinition = hook.get_service_definition()
+    service_definition = ServiceDefinition(hook, instance_id)
+    if not service_definition.send():
+        # Countdown is in seconds
+        countdown = HookLog.get_remaining_seconds(self.request.retries)
+        raise self.retry(countdown=countdown, max_retries=constance.config.HOOK_MAX_RETRIES)
+
+    return True
+
+
+@shared_task
+def retry_all_task(hooklogs_ids):
+    """
+    :param list: <int>.
+    """
+    hook_logs = HookLog.objects.filter(id__in=hooklogs_ids)
+    for hook_log in hook_logs:
+        hook_log.retry()
+        time.sleep(0.2)
+
+    return True
\ No newline at end of file
diff --git a/kobo/apps/hook/tests/__init__.py b/kobo/apps/hook/tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/kobo/apps/hook/tests/test_api_hook.py b/kobo/apps/hook/tests/test_api_hook.py
new file mode 100644
index 0000000000..69e0a3ebe0
--- /dev/null
+++ b/kobo/apps/hook/tests/test_api_hook.py
@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+import json
+import requests
+import responses
+
+from django.conf import settings
+from django.core.urlresolvers import reverse
+from rest_framework import status
+
+from ..constants import HOOK_LOG_FAILED
+from ..models.hook_log import HookLog
+from kpi.constants import INSTANCE_FORMAT_TYPE_JSON
+from kpi.tests.kpi_test_case import KpiTestCase
+
+
+class ApiHookTestCase(KpiTestCase):
+
+    def setUp(self):
+        self.client.login(username="someuser", password="someuser")
+        self.asset = self.create_asset(
+            "some_asset",
+            content=json.dumps({"survey": [{"type": "text", "name": "q1"}]}),
+            format="json")
+        self.asset.deploy(backend='mock', active=True)
+        self.asset.save()
+
+        v_uid = self.asset.latest_deployed_version.uid
+        submission = {
+            "__version__": v_uid,
+            "q1": u"¿Qué tal?",
+            "id": 1
+        }
+        self.asset.deployment._mock_submission(submission)
+        self.asset.save(create_version=False)
+        settings.CELERY_ALWAYS_EAGER = True
+
+    def _create_hook(self):
+        url = reverse("hook-list", kwargs={"parent_lookup_asset": self.asset.uid})
+        data = {
+            "name": "some external service with token",
+            "endpoint": "http://external.service.local/",
+            "settings": {
+                "custom_headers": {
+                    "X-Token": "1234abcd"
+                }
+            }
+        }
+        response = self.client.post(url, data, format=INSTANCE_FORMAT_TYPE_JSON)
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED,
+                         msg=response.data)
+        hook = self.asset.hooks.last()
+        self.assertTrue(hook.active)
+        return hook
+
+    def test_anonymous_access(self):
+        hook = self._create_hook()
+        self.client.logout()
+
+        list_url = reverse("hook-list", kwargs={
+            "parent_lookup_asset": self.asset.uid
+        })
+
+        response = self.client.get(list_url)
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        detail_url = reverse("hook-detail", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "uid": hook.uid,
+        })
+
+        response = self.client.get(detail_url)
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        log_list_url = reverse("hook-log-list", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "parent_lookup_hook": hook.uid,
+        })
+
+        response = self.client.get(log_list_url)
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+
+    def test_not_owner_access(self):
+        hook = self._create_hook()
+        self.client.logout()
+        self.client.login(username="anotheruser", password="anotheruser")
+
+        list_url = reverse("hook-list", kwargs={
+            "parent_lookup_asset": self.asset.uid
+        })
+
+        response = self.client.get(list_url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        detail_url = reverse("hook-detail", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "uid": hook.uid,
+        })
+
+        response = self.client.get(detail_url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        log_list_url = reverse("hook-log-list", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "parent_lookup_hook": hook.uid,
+        })
+
+        response = self.client.get(log_list_url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+
+    def test_create_hook(self):
+        self._create_hook()
+
+    def test_partial_update_hook(self):
+        hook = self._create_hook()
+        url = reverse("hook-detail", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "uid": hook.uid
+        })
+        data = {
+            "name": "some disabled external service",
+            "active": False
+        }
+        response = self.client.patch(url, data, format=INSTANCE_FORMAT_TYPE_JSON)
+        self.assertEqual(response.status_code, status.HTTP_200_OK,
+                         msg=response.data)
+        hook.refresh_from_db()
+        self.assertFalse(hook.active)
+        self.assertEqual(hook.name, "some disabled external service")
+
+    @responses.activate
+    def test_send_and_retry(self):
+        hook = self._create_hook()
+
+        ServiceDefinition = hook.get_service_definition()
+        submissions = self.asset.deployment.get_submissions()
+        uuid = submissions[0].get("id")
+        service_definition = ServiceDefinition(hook, uuid)
+        first_mock_response = {"error": "not found"}
+
+        # Mock first requests try
+        responses.add(responses.POST, hook.endpoint,
+                      json=first_mock_response, status=status.HTTP_404_NOT_FOUND)
+        # Mock next requests tries
+        responses.add(responses.POST, hook.endpoint,
+                      status=status.HTTP_200_OK,
+                      content_type="application/json")
+
+        # Try to send data to external endpoint
+        success = service_definition.send()
+        self.assertFalse(success)
+
+        # Retrieve the corresponding log
+        url = reverse("hook-log-list", kwargs={
+            "parent_lookup_asset": hook.asset.uid,
+            "parent_lookup_hook": hook.uid
+        })
+
+        response = self.client.get(url, format=INSTANCE_FORMAT_TYPE_JSON)
+        first_hooklog = response.data.get("results")[0]
+
+        # Result should match first try
+        self.assertEqual(first_hooklog.get("status_code"), status.HTTP_404_NOT_FOUND)
+        self.assertEqual(json.loads(first_hooklog.get("message")), first_mock_response)
+
+        # Let's retry through API call
+        retry_url = reverse("hook-log-retry", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "parent_lookup_hook": hook.uid,
+            "uid": first_hooklog.get("uid")
+        })
+
+        # Fakes Celery n retries by forcing status to `failed` (where n is `settings.HOOKLOG_MAX_RETRIES`)
+        fhl = HookLog.objects.get(uid=first_hooklog.get("uid"))
+        fhl.change_status(HOOK_LOG_FAILED)
+
+        # It should be a success
+        response = self.client.patch(retry_url, format=INSTANCE_FORMAT_TYPE_JSON)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Let's check if logs has 2 tries
+        detail_url = reverse("hook-log-detail", kwargs={
+            "parent_lookup_asset": self.asset.uid,
+            "parent_lookup_hook": hook.uid,
+            "uid": first_hooklog.get("uid")
+        })
+
+        response = self.client.get(detail_url, format=INSTANCE_FORMAT_TYPE_JSON)
+        self.assertEqual(response.data.get("tries"), 2)
\ No newline at end of file
diff --git a/kobo/apps/hook/utils.py b/kobo/apps/hook/utils.py
new file mode 100644
index 0000000000..519d17b15d
--- /dev/null
+++ b/kobo/apps/hook/utils.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from .models.hook_log import HookLog
+from .tasks import service_definition_task
+
+
+class HookUtils(object):
+
+    @staticmethod
+    def call_services(asset, instance_id):
+        """
+        Delegates to Celery data submission to remote servers
+
+        :param asset: Asset.
+        :param instance_id: int. Instance primary key
+        """
+        # Retrieve `Hook` ids, to send data to their respective endpoint.
+        hooks_ids = asset.hooks.filter(active=True).values_list("id", flat=True).distinct()
+        # At least, one of the hooks must not have a log that corresponds to `instance_id`
+        # to make success equal True
+        success = False
+        for hook_id in hooks_ids:
+            if not HookLog.objects.filter(instance_id=instance_id, hook_id=hook_id).exists():
+                success = True
+                service_definition_task.delay(hook_id, instance_id)
+
+        return success
diff --git a/kobo/apps/hook/views/__init__.py b/kobo/apps/hook/views/__init__.py
new file mode 100644
index 0000000000..f114974daa
--- /dev/null
+++ b/kobo/apps/hook/views/__init__.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from .hook import HookViewSet
+from .hook_log import HookLogViewSet
\ No newline at end of file
diff --git a/kobo/apps/hook/views/hook.py b/kobo/apps/hook/views/hook.py
new file mode 100644
index 0000000000..81f0bf5f15
--- /dev/null
+++ b/kobo/apps/hook/views/hook.py
@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+from datetime import datetime, timedelta
+import json
+
+import constance
+from django.utils import timezone
+from django.db.models import Q
+from django.shortcuts import get_object_or_404
+from django.utils.translation import ugettext as _
+from rest_framework import viewsets, status
+from rest_framework.decorators import detail_route
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework_extensions.mixins import NestedViewSetMixin
+
+from ..constants import HOOK_LOG_FAILED, HOOK_LOG_PENDING
+from ..tasks import retry_all_task
+from ..models import Hook, HookLog
+from ..serializers.hook import HookSerializer
+from kpi.constants import INSTANCE_FORMAT_TYPE_JSON
+from kpi.models import Asset
+from kpi.views import AssetOwnerFilterBackend, SubmissionViewSet
+from kpi.utils.log import logging
+
+
+class HookViewSet(NestedViewSetMixin, viewsets.ModelViewSet):
+    """
+
+    ## External services
+
+    Lists the external services endpoints accessible to requesting user
+
+    <pre class="prettyprint">
+    <b>GET</b> /assets/{asset_uid}/hooks/
+    </pre>
+
+    > Example
+    >
+    >       curl -X GET https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/
+
+    ## CRUD
+
+    * `asset_uid` - is the unique identifier of a specific asset
+    * `uid` - is the unique identifier of a specific external service
+
+    #### Retrieves an external service
+    <pre class="prettyprint">
+    <b>GET</b> /assets/<code>{asset_uid}</code>/hooks/<code>{uid}</code>
+    </pre>
+
+
+    > Example
+    >
+    >       curl -X GET https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hfgha2nxBdoTVcwohdYNzb
+
+    #### Add an external service to asset.
+    <pre class="prettyprint">
+    <b>POST</b> /assets/<code>{asset_uid}</code>/hooks/
+    </pre>
+
+
+    > Example
+    >
+    >       curl -X POST https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/
+
+
+    > **Payload to create a new external service**
+    >
+    >        {
+    >           "name": {string},
+    >           "endpoint": {string},
+    >           "active": {boolean},
+    >           "export_type": {string},
+    >           "auth_level": {string},
+    >           "settings": {
+    >               "username": {string},
+    >               "password": {string},
+    >               "custom_headers": {
+    >                   {string}: {string}
+    >                   ...
+    >                   {string}: {string}
+    >               }
+    >           }
+    >        }
+
+    where
+
+    * `name` and `endpoint` are required
+    * `active` is True by default
+    * `export_type` must be one these values:
+
+        1. `json` (_default_)
+        2. `xml`
+
+    * `auth_level` must be one these values:
+
+        1. `no_auth` (_default_)
+        2. `basic_auth`
+
+    * `settings`.`custom_headers` is dictionary of `custom header`: `value`
+
+    For example:
+    >           "settings": {
+    >               "customer_headers": {
+    >                   "Authorization" : "Token 1af538baa9045a84c0e889f672baf83ff24"
+    >               }
+
+    #### Update an external service.
+    <pre class="prettyprint">
+    <b>PATCH</b> /assets/<code>{asset_uid}</code>/hooks/{uid}
+    </pre>
+
+
+    > Example
+    >
+    >       curl -X PATCH https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hfgha2nxBdoTVcwohdYNzb
+
+
+    Only specify properties to update in the payload. See above for payload structure
+
+    #### Delete an external service.
+    <pre class="prettyprint">
+    <b>DELETE</b> /assets/<code>{asset_uid}</code>/hooks/{uid}
+    </pre>
+
+
+    > Example
+    >
+    >       curl -X DELETE https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hfgha2nxBdoTVcwohdYNzb
+
+    #### Retries all failed attempts <span class='label label-danger'>Not implemented yet</span>
+    <pre class="prettyprint">
+    <b>PATCH</b> /assets/<code>{asset_uid}</code>/hooks/<code>{hook_uid}</code>/retry/
+    </pre>
+
+
+    ### CURRENT ENDPOINT
+    """
+    model = Hook
+    lookup_field = "uid"
+    filter_backends = (
+        AssetOwnerFilterBackend,
+    )
+    serializer_class = HookSerializer
+    permission_classes = (IsAuthenticated,)
+
+    def get_queryset(self):
+        asset_uid = self.get_parents_query_dict().get("asset")
+        queryset = self.model.objects.filter(asset__uid=asset_uid)
+        queryset = queryset.select_related("asset__uid")
+        return queryset
+
+    def list(self, request, *args, **kwargs):
+        # Because object permissions is done on hook only,
+        # we need to check whether the user is the owner of the user to return a 404 when it's not.
+        # We prefer to return 404 instead of 403 to avoid to expose existence of the Asset/Hook
+        # to unauthorized user
+        asset_uid = self.get_parents_query_dict().get("asset")
+        asset = get_object_or_404(Asset, uid=asset_uid, owner=request.user)
+        return super(HookViewSet, self).list(request, *args, **kwargs)
+
+    def perform_create(self, serializer):
+        asset_uid = self.get_parents_query_dict().get("asset")
+        asset = get_object_or_404(Asset, uid=asset_uid)
+        serializer.save(asset=asset)
+
+    @detail_route(methods=["PATCH"])
+    def retry(self, request, uid=None, *args, **kwargs):
+        hook = self.get_object()
+        response = {"detail": _("Task successfully scheduled")}
+        status_code = status.HTTP_200_OK
+        if hook.active:
+            seconds = HookLog.get_elapsed_seconds(constance.config.HOOK_MAX_RETRIES)
+            threshold = timezone.now() - timedelta(seconds=seconds)
+
+            records = hook.logs.filter(Q(date_modified__lte=threshold, status=HOOK_LOG_PENDING) |
+                                    Q(status=HOOK_LOG_FAILED)).values_list("id", "uid").distinct()
+            # Prepare lists of ids
+            hooklogs_ids = []
+            hooklogs_uids = []
+            for record in records:
+                hooklogs_ids.append(record[0])
+                hooklogs_uids.append(record[1])
+
+            if len(records) > 0:
+                # Mark all logs as PENDING
+                HookLog.objects.filter(id__in=hooklogs_ids).update(status=HOOK_LOG_PENDING)
+                # Delegate to Celery
+                retry_all_task.delay(hooklogs_ids)
+                response.update({
+                    "pending_uids": hooklogs_uids
+                })
+
+            else:
+                response["detail"] = _("No data to retry")
+                status_code = status.HTTP_304_NOT_MODIFIED
+        else:
+            response["detail"] = _("Can not retry on disabled hooks")
+            status_code = status.HTTP_400_BAD_REQUEST
+
+        return Response(response, status=status_code)
\ No newline at end of file
diff --git a/kobo/apps/hook/views/hook_log.py b/kobo/apps/hook/views/hook_log.py
new file mode 100644
index 0000000000..1430847dc0
--- /dev/null
+++ b/kobo/apps/hook/views/hook_log.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+import json
+
+from django.shortcuts import get_object_or_404
+from django.utils.translation import ugettext as _
+from rest_framework import viewsets, mixins, status
+from rest_framework.decorators import detail_route
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework_extensions.mixins import NestedViewSetMixin
+
+from ..constants import KOBO_INTERNAL_ERROR_STATUS_CODE
+from ..models.hook_log import HookLog
+from ..serializers.hook_log import HookLogSerializer
+from kpi.models import Asset
+from kpi.serializers import TinyPaginated
+from kpi.views import AssetOwnerFilterBackend, SubmissionViewSet
+
+
+class HookLogViewSet(NestedViewSetMixin,
+                     mixins.RetrieveModelMixin,
+                     mixins.ListModelMixin,
+                     viewsets.GenericViewSet):
+    """
+    ## Logs of an external service
+
+    ** Users can't add, update or delete logs with the API. They can only retry failed attempts (see below)**
+
+    #### Lists logs of an external services endpoints accessible to requesting user
+    <pre class="prettyprint">
+    <b>GET</b> /assets/{asset_uid}/hooks/{hook_uid}/logs/
+    </pre>
+
+    > Example
+    >
+    >       curl -X GET https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hSBxsiVNa5UxkVAjwu6dFB/logs/
+
+
+
+    * `asset_uid` - is the unique identifier of a specific asset
+    * `hook_uid` - is the unique identifier of a specific external service
+    * `uid` - is the unique identifier of a specific log
+
+    #### Retrieves a log
+    <pre class="prettyprint">
+    <b>GET</b> /assets/<code>{asset_uid}</code>/hooks/<code>{hook_uid}</code>/logs/<code>{uid}</code>/
+    </pre>
+
+
+    > Example
+    >
+    >       curl -X GET https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hfgha2nxBdoTVcwohdYNzb/logs/3005940a-6e30-4699-813a-0ee5b2b07395/
+
+
+    #### Retries a failed attempt
+    <pre class="prettyprint">
+    <b>PATCH</b> /assets/<code>{asset_uid}</code>/hooks/<code>{hook_uid}</code>/logs/<code>{uid}</code>/retry/
+    </pre>
+
+    > Example
+    >
+    >       curl -X GET https://[kpi-url]/assets/a9PkXcgVgaDXuwayVeAuY5/hooks/hfgha2nxBdoTVcwohdYNzb/logs/3005940a-6e30-4699-813a-0ee5b2b07395/retry/
+
+
+    ### CURRENT ENDPOINT
+    """
+    model = HookLog
+
+    lookup_field = "uid"
+    filter_backends = (
+        AssetOwnerFilterBackend,
+    )
+    serializer_class = HookLogSerializer
+    permission_classes = (IsAuthenticated,)
+    pagination_class = TinyPaginated
+
+    def get_queryset(self):
+        asset_uid = self.get_parents_query_dict().get("asset")
+        hook_uid = self.get_parents_query_dict().get("hook")
+        queryset = self.model.objects.filter(hook__uid=hook_uid, hook__asset__uid=asset_uid)
+        queryset = queryset.select_related("hook__asset__uid")
+
+        return queryset
+
+    def list(self, request, *args, **kwargs):
+        # Same as HookViewSet.list()
+        asset_uid = self.get_parents_query_dict().get("asset")
+        asset = get_object_or_404(Asset, uid=asset_uid, owner=request.user)
+        return super(HookLogViewSet, self).list(request, *args, **kwargs)
+
+    @detail_route(methods=["PATCH"])
+    def retry(self, request, uid=None, *args, **kwargs):
+        """
+        Retries to send data to external service.
+        :param request: rest_framework.request.Request
+        :param uid: str
+        :return: Response
+        """
+        response = {"detail": "",
+                    "status_code": KOBO_INTERNAL_ERROR_STATUS_CODE}
+        status_code = status.HTTP_200_OK
+        hook_log = self.get_object()
+
+        if hook_log.can_retry():
+            hook_log.change_status()
+            success = hook_log.retry()
+            if success:
+                # Return status_code of remote server too.
+                # `response["status_code"]` is not the same as `status_code`
+                response["detail"] = hook_log.message
+                response["status_code"] = hook_log.status_code
+            else:
+                response["detail"] = _("An error has occurred when sending the data. Please try again later.")
+                status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+        else:
+            response["detail"] = _("Data is being or has already been processed")
+            status_code = status.HTTP_400_BAD_REQUEST
+
+        return Response(response, status=status_code)
\ No newline at end of file
diff --git a/kobo/apps/reports/report_data.py b/kobo/apps/reports/report_data.py
index 576febb6a7..1d3323dfb1 100644
--- a/kobo/apps/reports/report_data.py
+++ b/kobo/apps/reports/report_data.py
@@ -1,7 +1,6 @@
 # coding: utf-8
 from __future__ import unicode_literals
 
-import logging
 import itertools
 from collections import OrderedDict
 from copy import deepcopy
@@ -11,21 +10,8 @@
 from formpack import FormPack
 from rest_framework import serializers
 
-from kpi.utils.mongo_helper import MongoDecodingHelper
-
-from .constants import (SPECIFIC_REPORTS_KEY, DEFAULT_REPORTS_KEY
-                        )
-
-
-def get_instances_for_userform_id(userform_id, submission=None):
-    query = {'_userform_id': userform_id, '_deleted_at': {'$exists': False}}
-    if submission:
-        query['_id'] = submission
-    instances = settings.MONGO_DB.instances.find(query)
-    return (
-        MongoDecodingHelper.to_readable_dict(instance)
-            for instance in instances
-    )
+from .constants import SPECIFIC_REPORTS_KEY, DEFAULT_REPORTS_KEY
+from kpi.utils.log import logging
 
 
 def build_formpack(asset, submission_stream=None, use_all_form_versions=True):
@@ -115,7 +101,8 @@ def _infer_version_id(submission):
         _userform_id = asset.deployment.mongo_userform_id
         if not _userform_id.startswith(asset.owner.username):
             raise Exception('asset has unexpected `mongo_userform_id`')
-        submission_stream = get_instances_for_userform_id(_userform_id)
+
+        submission_stream = asset.deployment.get_submissions()
 
     submission_stream = (
         _infer_version_id(submission) for submission in submission_stream
diff --git a/kobo/settings.py b/kobo/settings.py
index 0f634e5bb0..8c63384c5b 100644
--- a/kobo/settings.py
+++ b/kobo/settings.py
@@ -92,6 +92,7 @@
     'constance',
     'constance.backends.database',
     'guardian', # For access to KC permissions ONLY
+    'kobo.apps.hook',
 )
 
 MIDDLEWARE_CLASSES = (
@@ -136,7 +137,9 @@
                                        'help@kobotoolbox.org'),
                       'Email address for users to contact, e.g. when they '
                       'encounter unhandled errors in the application'),
-
+    'HOOK_MAX_RETRIES': (3,
+                         'Number of times the system will retry '
+                         'to send data to remote server before giving up')
 }
 # Tell django-constance to use a database model instead of Redis
 CONSTANCE_BACKEND = 'constance.backends.database.DatabaseBackend'
@@ -269,6 +272,11 @@ def __init__(self, *args, **kwargs):
         'rest_framework.authentication.BasicAuthentication',
         'rest_framework.authentication.TokenAuthentication',
     ],
+    'DEFAULT_RENDERER_CLASSES': [
+        'rest_framework.renderers.JSONRenderer',
+        'rest_framework.renderers.BrowsableAPIRenderer',
+        'rest_framework_xml.renderers.XMLRenderer',
+    ]
 }
 
 TEMPLATES = [
@@ -475,6 +483,37 @@ def __init__(self, *args, **kwargs):
             'private_storage.storage.s3boto3.PrivateS3BotoStorage'
         AWS_PRIVATE_STORAGE_BUCKET_NAME = AWS_STORAGE_BUCKET_NAME
 
+
+# Need a default logger when sentry is not activated
+
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'verbose': {
+            'format': '%(levelname)s %(asctime)s %(module)s' +
+                      ' %(process)d %(thread)d %(message)s'
+        },
+        'simple': {
+            'format': '%(levelname)s %(message)s'
+        },
+    },
+    'handlers': {
+        'console': {
+            'level': 'DEBUG',
+            'class': 'logging.StreamHandler',
+            'formatter': 'verbose'
+        }
+    },
+    'loggers': {
+        'console_logger': {
+            'handlers': ['console'],
+            'level': 'DEBUG',
+            'propagate': True
+        }
+    }
+}
+
 ''' Sentry configuration '''
 if os.environ.get('RAVEN_DSN', False):
     import raven
@@ -541,6 +580,11 @@ def __init__(self, *args, **kwargs):
                 'handlers': ['console'],
                 'propagate': False,
             },
+            'console_logger': {
+                'level': 'DEBUG',
+                'handlers': ['console'],
+                'propagate': True
+            },
         },
     }
 
@@ -600,4 +644,4 @@ def __init__(self, *args, **kwargs):
 
 MONGO_CONNECTION = MongoClient(
     MONGO_CONNECTION_URL, j=True, tz_aware=True, connect=False)
-MONGO_DB = MONGO_CONNECTION[MONGO_DATABASE['NAME']]
+MONGO_DB = MONGO_CONNECTION[MONGO_DATABASE['NAME']]
\ No newline at end of file
diff --git a/kpi/constants.py b/kpi/constants.py
index e9ac482007..1979ed06f1 100644
--- a/kpi/constants.py
+++ b/kpi/constants.py
@@ -1,5 +1,6 @@
 
-
+INSTANCE_FORMAT_TYPE_XML = "xml"
+INSTANCE_FORMAT_TYPE_JSON = "json"
 
 ASSET_TYPE_TEXT = 'text'
 ASSET_TYPE_EMPTY = 'empty'
diff --git a/kpi/deployment_backends/kc_access/utils.py b/kpi/deployment_backends/kc_access/utils.py
index 3f4e80a3de..70a920cf51 100644
--- a/kpi/deployment_backends/kc_access/utils.py
+++ b/kpi/deployment_backends/kc_access/utils.py
@@ -1,6 +1,4 @@
-import logging
 import json
-import logging
 from collections import Iterable
 
 from django.conf import settings
@@ -13,6 +11,7 @@
 import requests
 
 from .shadow_models import _models, safe_kc_read
+from kpi.utils.log import logging
 
 
 class _KoboCatProfileException(Exception):
diff --git a/kpi/deployment_backends/kobocat_backend.py b/kpi/deployment_backends/kobocat_backend.py
index 2877a4d030..9bb89ffbf9 100644
--- a/kpi/deployment_backends/kobocat_backend.py
+++ b/kpi/deployment_backends/kobocat_backend.py
@@ -1,8 +1,9 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
+from __future__ import absolute_import
 
 import cStringIO
-import logging
+import json
 import re
 import requests
 import unicodecsv
@@ -11,16 +12,19 @@
 
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
-from django.http import HttpResponse
-from django.shortcuts import get_object_or_404
 from django.utils.translation import ugettext_lazy as _
 from pyxform.xls2json_backends import xls_to_dict
 from rest_framework import exceptions, status, serializers
+from rest_framework.request import Request
 from rest_framework.authtoken.models import Token
-from rest_framework.decorators import detail_route, list_route
 
-from base_backend import BaseDeploymentBackend
+from .base_backend import BaseDeploymentBackend
 from .kc_access.utils import instance_count, last_submission_time
+from .kc_access.shadow_models import _models
+from ..exceptions import BadFormatException
+from kpi.constants import INSTANCE_FORMAT_TYPE_JSON, INSTANCE_FORMAT_TYPE_XML
+from kpi.utils.mongo_helper import MongoDecodingHelper
+from kpi.utils.log import logging
 
 
 class KobocatDeploymentException(exceptions.APIException):
@@ -259,7 +263,10 @@ def connect(self, identifier=None, active=False):
                 }
             }
         )
-        payload = {u'downloadable': active}
+        payload = {
+            u"downloadable": active,
+            u"has_kpi_hook": self.asset.has_active_hooks
+        }
         files = {'xls_file': (u'{}.xls'.format(id_string), xls_io)}
         json_response = self._kobocat_request(
             'POST', url, data=payload, files=files)
@@ -289,8 +296,9 @@ def redeploy(self, active=None):
             }
         )
         payload = {
-            u'downloadable': active,
-            u'title': self.asset.name
+            u"downloadable": active,
+            u"title": self.asset.name,
+            u"has_kpi_hook": self.asset.has_active_hooks
         }
         files = {'xls_file': (u'{}.xls'.format(id_string), xls_io)}
         try:
@@ -327,6 +335,27 @@ def set_active(self, active):
             'backend_response': json_response,
         })
 
+    def set_has_kpi_hooks(self):
+        """
+        PATCH `has_kpi_hooks` boolean of survey.
+        It lets `kc` know whether it needs to ping `kpi`
+        each time a submission comes in.
+
+        Store results in self.asset._deployment_data
+        """
+        has_active_hooks = self.asset.has_active_hooks
+        url = self.external_to_internal_url(
+            self.backend_response["url"])
+        payload = {
+            u"has_kpi_hooks": has_active_hooks
+        }
+        json_response = self._kobocat_request("PATCH", url, data=payload)
+        assert(json_response["has_kpi_hooks"] == has_active_hooks)
+        self.store_data({
+            "has_kpi_hooks": json_response.get("has_kpi_hooks"),
+            "backend_response": json_response,
+        })
+
     def delete(self):
         ''' WARNING! Deletes all submitted data! '''
         url = self.external_to_internal_url(self.backend_response['url'])
@@ -449,132 +478,79 @@ def get_submission_validation_status_url(self, submission_pk):
         )
         return url
 
-class KobocatDataProxyViewSetMixin(object):
-    '''
-    List, retrieve, and delete submission data for a deployed asset via the
-    KoBoCAT API.
-    '''
-    def _get_deployment(self, request):
-        '''
-        Presupposing the use of `NestedViewSetMixin`, return the deployment for
-        the asset specified by the KPI request
-        '''
-        asset_uid = self.get_parents_query_dict()['asset']
-        asset = get_object_or_404(self.parent_model, uid=asset_uid)
-        if not asset.has_deployment:
-            raise serializers.ValidationError(
-                _('The specified asset has not been deployed'))
-        if not isinstance(asset.deployment, KobocatDeploymentBackend):
-            raise NotImplementedError(
-                'This viewset can only be used with the KoBoCAT deployment '
-                'backend')
-        return asset.deployment
-
-    @staticmethod
-    def _kobocat_proxy_request(kpi_request, kc_request):
-        '''
-        Send `kc_request`, which must specify `method` and `url` at a minimum.
-        If `kpi_request`, i.e. the incoming request to be proxied, is
-        authenticated, logged-in user's API token will be added to
-        `kc_request.headers`
-        '''
-        user = kpi_request.user
-        if not user.is_anonymous() and user.pk != settings.ANONYMOUS_USER_ID:
-            token, created = Token.objects.get_or_create(user=user)
-            kc_request.headers['Authorization'] = 'Token %s' % token.key
-        session = requests.Session()
-        return session.send(kc_request.prepare())
+    def get_submissions(self, format_type=INSTANCE_FORMAT_TYPE_JSON, instances_ids=[]):
+        """
+        Retreives submissions through Postgres or Mongo depending on `format_type`.
+        It can be filtered on instances uuids.
+        `uuid` is used instead of `id` because `id` is not available in ReadOnlyInstance model
+
+        :param format_type: str. INSTANCE_FORMAT_TYPE_JSON|INSTANCE_FORMAT_TYPE_XML
+        :param instances_ids: list. Optional
+        :return: list: mixed
+        """
+        submissions = []
+        getter = getattr(self, "_{}__get_submissions_in_{}".format(
+            self.__class__.__name__,
+            format_type))
+        try:
+            submissions = getter(instances_ids)
+        except Exception as e:
+            logging.error("KobocatDeploymentBackend.get_submissions  - {}".format(str(e)))
 
-    @staticmethod
-    def _requests_response_to_django_response(requests_response):
-        '''
-        Convert a `requests.models.Response` into a `django.http.HttpResponse`
-        '''
-        HEADERS_TO_COPY = ('Content-Type', 'Content-Language')
-        django_response = HttpResponse()
-        for header in HEADERS_TO_COPY:
-            try:
-                django_response[header] = requests_response.headers[header]
-            except KeyError:
-                continue
-        django_response.status_code = requests_response.status_code
-        django_response.write(requests_response.content)
-        return django_response
+        return submissions
 
+    def get_submission(self, pk, format_type=INSTANCE_FORMAT_TYPE_JSON):
+        """
+        Returns only one occurrence.
 
-    def list(self, kpi_request, *args, **kwargs):
-        return self.retrieve(kpi_request, None, *args, **kwargs)
+        :param pk: int. `Instance.id`
+        :param format_type: str.  INSTANCE_FORMAT_TYPE_JSON|INSTANCE_FORMAT_TYPE_XML
+        :return: mixed. JSON or XML
+        """
 
-    def retrieve(self, kpi_request, pk, *args, **kwargs):
-        deployment = self._get_deployment(kpi_request)
-        if pk is None:
-            kc_url = deployment.submission_list_url
+        if pk:
+            submissions = list(self.get_submissions(format_type, [pk]))
+            if len(submissions) > 0:
+                return submissions[0]
+            return None
         else:
-            kc_url = deployment.get_submission_detail_url(pk)
-        kc_request = requests.Request(
-            method='GET',
-            url=kc_url,
-            params=kpi_request.GET
-        )
-        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
-        return self._requests_response_to_django_response(kc_response)
-
-    def delete(self, kpi_request, pk, *args, **kwargs):
-        deployment = self._get_deployment(kpi_request)
-        kc_url = deployment.get_submission_detail_url(pk)
-        kc_request = requests.Request(method='DELETE', url=kc_url)
-        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
-        return self._requests_response_to_django_response(kc_response)
-
-    @detail_route(methods=['GET'])
-    def edit(self, kpi_request, pk, *args, **kwargs):
-        deployment = self._get_deployment(kpi_request)
-        kc_url = deployment.get_submission_edit_url(pk)
-        kc_request = requests.Request(
-            method='GET',
-            url=kc_url,
-            params=kpi_request.GET
-        )
-        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
-        return self._requests_response_to_django_response(kc_response)
-
-    @detail_route(methods=["GET", "PATCH"])
-    def validation_status(self, kpi_request, pk, *args, **kwargs):
-        deployment = self._get_deployment(kpi_request)
-        kc_url = deployment.get_submission_validation_status_url(pk)
-
-        requests_params = {
-            "method": kpi_request.method,
-            "url": kc_url
+            raise ValueError("Primary key must be provided")
+
+    def __get_submissions_in_json(self, instances_ids=[]):
+        """
+        Retrieves instances directly from Mongo.
+
+        :param instances_ids: list. Optional
+        :return: generator<JSON>
+        """
+        query = {
+            "_xform_id_string": self.asset.uid,
+            "_deleted_at": {"$exists": False}
         }
 
-        # According to HTTP method,
-        # params are passed to Request object in different ways.
-        http_method_params = {}
-        if kpi_request.method == "PATCH":
-            http_method_params = {"json": kpi_request.data}
-        else:
-            http_method_params = {"params": kpi_request.GET}
-
-        requests_params.update(http_method_params)
-        kc_request = requests.Request(**requests_params)
-        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
-
-        return self._requests_response_to_django_response(kc_response)
+        if len(instances_ids) > 0:
+            query.update({
+                "_id": {"$in": instances_ids}
+            })
 
+        instances = settings.MONGO_DB.instances.find(query)
+        return (
+            MongoDecodingHelper.to_readable_dict(instance)
+            for instance in instances
+        )
 
-    @list_route(methods=["PATCH"])
-    def validation_statuses(self, kpi_request, *args, **kwargs):
-        deployment = self._get_deployment(kpi_request)
-        kc_url = deployment.submission_list_url
+    def __get_submissions_in_xml(self, instances_ids=[]):
+        """
+        Retrieves instances directly from Postgres.
 
-        requests_params = {
-            "method": kpi_request.method,
-            "url": kc_url,
-            "json": kpi_request.data
-        }
+        :param instances_ids: list. Optional
+        :return: list<XML>
+        """
+        queryset = _models.Instance.objects.filter(
+            xform__id_string=self.asset.uid,
+            deleted_at=None)
 
-        kc_request = requests.Request(**requests_params)
-        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+        if len(instances_ids) > 0:
+            queryset = queryset.filter(id__in=instances_ids)
 
-        return self._requests_response_to_django_response(kc_response)
+        return (lazy_instance.xml for lazy_instance in queryset)
\ No newline at end of file
diff --git a/kpi/deployment_backends/mixin.py b/kpi/deployment_backends/mixin.py
index bb978e0625..4449c46f79 100644
--- a/kpi/deployment_backends/mixin.py
+++ b/kpi/deployment_backends/mixin.py
@@ -1,6 +1,20 @@
-#!/usr/bin/python
 # -*- coding: utf-8 -*-
-from backends import DEPLOYMENT_BACKENDS
+from __future__ import absolute_import
+import json
+
+from django.conf import settings
+from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
+from django.utils.translation import ugettext_lazy as _
+import requests
+from rest_framework import serializers
+from rest_framework.authtoken.models import Token
+from rest_framework.decorators import detail_route, list_route
+from requests.utils import quote
+
+from .backends import DEPLOYMENT_BACKENDS
+from .kobocat_backend import KobocatDeploymentBackend
+from .mock_backend import MockDeploymentBackend
 from kpi.exceptions import BadAssetTypeException
 from kpi.constants import ASSET_TYPE_SURVEY
 
@@ -18,7 +32,7 @@ def connect_deployment(self, **kwargs):
             raise KeyError('connect_deployment requires an argument: backend')
 
     def deploy(self, backend=False, active=True):
-        '''this method could be called "deploy_latest_version()".'''
+        """this method could be called "deploy_latest_version()"."""
 
         if self.can_be_deployed:
             if not self.has_deployment:
@@ -31,9 +45,9 @@ def deploy(self, backend=False, active=True):
                 self.asset_type))
 
     def _mark_latest_version_as_deployed(self):
-        ''' `sync_kobocat_xforms` calls this, since it manipulates
+        """ `sync_kobocat_xforms` calls this, since it manipulates
         `_deployment_data` directly. Everything else should probably call
-        `deploy()` above '''
+        `deploy()` above """
         latest_version = self.latest_version
         latest_version.deployed = True
         latest_version.save()
@@ -49,9 +63,204 @@ def deployment(self):
         try:
             backend = self._deployment_data['backend']
             return DEPLOYMENT_BACKENDS[backend](self)
-        except KeyError, e:
+        except KeyError as e:
             raise KeyError('cannot retrieve asset backend: {}'.format(backend))
 
     @property
     def can_be_deployed(self):
-        return self.asset_type and self.asset_type == ASSET_TYPE_SURVEY
\ No newline at end of file
+        return self.asset_type and self.asset_type == ASSET_TYPE_SURVEY
+
+
+class MockDataProxyViewSetMixin(object):
+
+    def retrieve(self, request, pk, *args, **kwargs):
+        asset = self._get_asset(kwargs.get("asset"))
+        if not asset.has_deployment:
+            raise serializers.ValidationError(
+                _('The specified asset has not been deployed'))
+        elif pk is None:
+            return HttpResponse(json.dumps(asset.deployment.get_submissions()),
+                                content_type="application/json")
+        else:
+            data = (submission for submission in asset.deployment.get_submissions()
+                    if submission.get("id") == pk).next()
+            return HttpResponse(json.dumps(data), content_type="application/json")
+
+    def _get_asset(self, asset):
+        if asset is None:
+            asset_uid = self.get_parents_query_dict()['asset']
+            asset = get_object_or_404(self.parent_model, uid=asset_uid)
+
+        return asset
+
+class KobocatDataProxyViewSetMixin(MockDataProxyViewSetMixin):
+    """
+    List, retrieve, and delete submission data for a deployed asset via the
+    KoBoCAT API.
+    """
+    def _get_deployment(self, request, asset=None):
+        """
+        Presupposing the use of `NestedViewSetMixin`, return the deployment for
+        the asset specified by the KPI request
+        """
+        asset = self._get_asset(asset)
+
+        if not asset.has_deployment:
+            raise serializers.ValidationError(
+                _('The specified asset has not been deployed'))
+        if not isinstance(asset.deployment, KobocatDeploymentBackend):
+            raise NotImplementedError(
+                'This viewset can only be used with the KoBoCAT deployment '
+                'backend')
+        return asset.deployment
+
+    @staticmethod
+    def _kobocat_proxy_request(kpi_request, kc_request):
+        """
+        Send `kc_request`, which must specify `method` and `url` at a minimum.
+        If `kpi_request`, i.e. the incoming request to be proxied, is
+        authenticated, logged-in user's API token will be added to
+        `kc_request.headers`
+        """
+        user = kpi_request.user
+        if not user.is_anonymous() and user.pk != settings.ANONYMOUS_USER_ID:
+            token, created = Token.objects.get_or_create(user=user)
+            kc_request.headers['Authorization'] = 'Token %s' % token.key
+        session = requests.Session()
+        return session.send(kc_request.prepare())
+
+    @staticmethod
+    def _requests_response_to_django_response(requests_response):
+        """
+        Convert a `requests.models.Response` into a `django.http.HttpResponse`
+        """
+        HEADERS_TO_COPY = ('Content-Type', 'Content-Language')
+        django_response = HttpResponse()
+        for header in HEADERS_TO_COPY:
+            try:
+                django_response[header] = requests_response.headers[header]
+            except KeyError:
+                continue
+        django_response.status_code = requests_response.status_code
+        django_response.write(requests_response.content)
+        return django_response
+
+
+    def list(self, kpi_request, *args, **kwargs):
+        return self.retrieve(kpi_request, None, *args, **kwargs)
+
+    def retrieve(self, kpi_request, pk, *args, **kwargs):
+
+        asset_uid = self.get_parents_query_dict()['asset']
+        asset = get_object_or_404(self.parent_model, uid=asset_uid)
+
+        if isinstance(asset.deployment, MockDeploymentBackend):
+            return super(KobocatDataProxyViewSetMixin, self).retrieve(
+                request=kpi_request,
+                pk=pk,
+                *args,
+                **kwargs)
+        else:
+            deployment = self._get_deployment(kpi_request, asset=asset)
+            if pk is None:
+                kc_url = deployment.submission_list_url
+            else:
+                kc_url = deployment.get_submission_detail_url(pk)
+
+            # We need to append query string parameters to url
+            # if any.
+            query_string_params = []
+            for key, value in kwargs.items():
+                if key.startswith("?"):
+                    query_string_params.append("{}={}".format(
+                        key[1:],
+                        value
+                    ))
+                    kwargs.pop(key)
+            if query_string_params:
+                kc_url = "{}?{}".format(
+                    kc_url,
+                    "&".join(query_string_params)
+                )
+
+            # We can now retrieve XML or JSON format from `kc`
+            # Request can be:
+            # - /assets/<parent_lookup_asset>/submissions/<pk>/
+
+            # - /assets/<parent_lookup_asset>/submissions/<pk>.<format>/
+            #   where `format` is among `kwargs`
+
+            # - /assets/<parent_lookup_asset>/submissions/<pk>?format=<format>/
+            #   where `format` is among `request.GET`
+            format = kwargs.pop("format", None)
+            params = kpi_request.GET.copy()
+            if format:
+                params.update({"format": format})
+
+            kc_request = requests.Request(
+                method='GET',
+                url=kc_url,
+                params=params
+            )
+            kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+            return self._requests_response_to_django_response(kc_response)
+
+    def delete(self, kpi_request, pk, *args, **kwargs):
+        deployment = self._get_deployment(kpi_request)
+        kc_url = deployment.get_submission_detail_url(pk)
+        kc_request = requests.Request(method='DELETE', url=kc_url)
+        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+        return self._requests_response_to_django_response(kc_response)
+
+    @detail_route(methods=['GET'])
+    def edit(self, kpi_request, pk, *args, **kwargs):
+        deployment = self._get_deployment(kpi_request)
+        kc_url = deployment.get_submission_edit_url(pk)
+        kc_request = requests.Request(
+            method='GET',
+            url=kc_url,
+            params=kpi_request.GET
+        )
+        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+        return self._requests_response_to_django_response(kc_response)
+
+    @detail_route(methods=["GET", "PATCH"])
+    def validation_status(self, kpi_request, pk, *args, **kwargs):
+        deployment = self._get_deployment(kpi_request)
+        kc_url = deployment.get_submission_validation_status_url(pk)
+
+        requests_params = {
+            "method": kpi_request.method,
+            "url": kc_url
+        }
+
+        # According to HTTP method,
+        # params are passed to Request object in different ways.
+        http_method_params = {}
+        if kpi_request.method == "PATCH":
+            http_method_params = {"json": kpi_request.data}
+        else:
+            http_method_params = {"params": kpi_request.GET}
+
+        requests_params.update(http_method_params)
+        kc_request = requests.Request(**requests_params)
+        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+
+        return self._requests_response_to_django_response(kc_response)
+
+
+    @list_route(methods=["PATCH"])
+    def validation_statuses(self, kpi_request, *args, **kwargs):
+        deployment = self._get_deployment(kpi_request)
+        kc_url = deployment.submission_list_url
+
+        requests_params = {
+            "method": kpi_request.method,
+            "url": kc_url,
+            "json": kpi_request.data
+        }
+
+        kc_request = requests.Request(**requests_params)
+        kc_response = self._kobocat_proxy_request(kpi_request, kc_request)
+
+        return self._requests_response_to_django_response(kc_response)
diff --git a/kpi/deployment_backends/mock_backend.py b/kpi/deployment_backends/mock_backend.py
index 3ad7413e30..1524acb1d4 100644
--- a/kpi/deployment_backends/mock_backend.py
+++ b/kpi/deployment_backends/mock_backend.py
@@ -2,6 +2,8 @@
 # -*- coding: utf-8 -*-
 
 from base_backend import BaseDeploymentBackend
+from kpi.constants import INSTANCE_FORMAT_TYPE_JSON, INSTANCE_FORMAT_TYPE_XML
+from kpi.exceptions import BadFormatException
 
 
 class MockDeploymentBackend(BaseDeploymentBackend):
@@ -56,5 +58,32 @@ def _mock_submission(self, submission):
             'submissions': submissions,
             })
 
-    def _get_submissions(self):
-        return self.asset._deployment_data.get('submissions', [])
+    def get_submissions(self, format_type=INSTANCE_FORMAT_TYPE_JSON, instances_ids=[]):
+        """
+        Returns a list of json representation of instances.
+
+        :param format: str. xml or json
+        :param instances_ids: list. Ids of instances to retrieve
+        :return: list
+        """
+        if format_type == INSTANCE_FORMAT_TYPE_XML:
+            raise BadFormatException("XML is not supported")
+        else:
+            submissions = self.asset._deployment_data.get("submissions", [])
+            if len(instances_ids) > 0:
+                instances_ids = [instance_id for instance_id in instances_ids]
+                submissions = [submission for submission in submissions if submission.get("id") in instances_ids]
+
+            return submissions
+
+    def get_submission(self, pk, format_type=INSTANCE_FORMAT_TYPE_JSON):
+         return self.get_submissions(format_type=format_type, instances_ids=[pk])[0]
+
+    def set_has_kpi_hooks(self):
+        """
+        Store results in self.asset._deployment_data
+        """
+        has_active_hooks = self.asset.has_active_hooks
+        self.store_data({
+            "has_kpi_hooks": has_active_hooks,
+        })
\ No newline at end of file
diff --git a/kpi/exceptions.py b/kpi/exceptions.py
index 4730f2ca4b..7d7187a6ca 100644
--- a/kpi/exceptions.py
+++ b/kpi/exceptions.py
@@ -1,4 +1,7 @@
 # -*- coding: utf-8 -*-
 
 class BadAssetTypeException(Exception):
+    pass
+
+class BadFormatException(Exception):
     pass
\ No newline at end of file
diff --git a/kpi/filters.py b/kpi/filters.py
index be72f704de..436c1beda0 100644
--- a/kpi/filters.py
+++ b/kpi/filters.py
@@ -18,17 +18,25 @@
 
 class AssetOwnerFilterBackend(filters.BaseFilterBackend):
     """
-    For use with AssetVersions
+    For use with nested models of Asset.
     Restricts access to items that are owned by the current user
     """
     def filter_queryset(self, request, queryset, view):
-        return queryset.filter(asset__owner=request.user)
+        # Because HookLog is two level nested,
+        # we need to specify the relation in the filter field
+        if type(view).__name__ == "HookLogViewSet":
+            fields = {"hook__asset__owner": request.user}
+        else:
+            fields = {"asset__owner": request.user}
+
+        return queryset.filter(**fields)
 
 
 class KpiObjectPermissionsFilter(object):
     perm_format = '%(app_label)s.view_%(model_name)s'
 
     def filter_queryset(self, request, queryset, view):
+
         user = request.user
         if user.is_superuser and view.action != 'list':
             # For a list, we won't deluge the superuser with everyone else's
diff --git a/kpi/fixtures/test_data.json b/kpi/fixtures/test_data.json
index 39cbddec26..52b33ad0f9 100644
--- a/kpi/fixtures/test_data.json
+++ b/kpi/fixtures/test_data.json
@@ -29,7 +29,6 @@
             "last_login": "2015-02-12T19:52:14.406Z",
             "last_name": "User",
             "password": "pbkdf2_sha256$15000$AGA044bkjSNO$jQx/SdL6ok6mFPRQhCuWtU9zNNFvRUQ7qexLZgLRiys=",
-            "user_permissions": [],
             "username": "someuser",
             "user_permissions" : [
                ["add_collection", "kpi", "collection"],
@@ -65,7 +64,6 @@
             "last_login": "2015-02-12T19:52:14.406Z",
             "last_name": "User",
             "password": "pbkdf2_sha256$15000$MQp3yLvTajFx$yttM5DVFuGpK8cSJI09tC55SeaEL2geWzk9ZDVMFWRw=",
-            "user_permissions": [],
             "username": "anotheruser",
             "user_permissions" : [
                ["add_collection", "kpi", "collection"],
diff --git a/kpi/haystack_utils.py b/kpi/haystack_utils.py
index dd1cce2128..711a38808b 100644
--- a/kpi/haystack_utils.py
+++ b/kpi/haystack_utils.py
@@ -1,10 +1,12 @@
 import contextlib
 import haystack
-import logging
+
 from django.apps import apps as kpi_apps
 from django.db import models
 from django.conf import settings
 from django.core import exceptions
+from kpi.utils.log import logging
+
 
 def update_object_in_search_index(obj):
     '''
diff --git a/kpi/management/commands/import_survey_drafts_from_dkobo.py b/kpi/management/commands/import_survey_drafts_from_dkobo.py
index 38f94ec17d..3895da4c55 100644
--- a/kpi/management/commands/import_survey_drafts_from_dkobo.py
+++ b/kpi/management/commands/import_survey_drafts_from_dkobo.py
@@ -1,7 +1,6 @@
 from StringIO import StringIO
 from optparse import make_option
 from pyxform.xls2json_backends import csv_to_dict
-import logging
 import re
 
 from django.contrib.auth.models import User
@@ -13,6 +12,7 @@
 from kpi.models import Asset
 from kpi.models import Collection
 from kpi.models.asset import KpiTaggableManager
+from kpi.utils.log import logging
 
 
 class SurveyDraft(models.Model):
diff --git a/kpi/management/commands/sync_kobocat_xforms.py b/kpi/management/commands/sync_kobocat_xforms.py
index 576b3a7691..cb0ed0ff7e 100644
--- a/kpi/management/commands/sync_kobocat_xforms.py
+++ b/kpi/management/commands/sync_kobocat_xforms.py
@@ -2,7 +2,6 @@
 import datetime
 import io
 import json
-import logging
 import re
 import requests
 import xlwt
@@ -26,6 +25,8 @@
 from ...deployment_backends.kc_access.shadow_models import _models
 from ...models import Asset, ObjectPermission
 from .import_survey_drafts_from_dkobo import _set_auto_field_update
+from kpi.utils.log import logging
+
 
 TIMESTAMP_DIFFERENCE_TOLERANCE = datetime.timedelta(seconds=30)
 
diff --git a/kpi/model_utils.py b/kpi/model_utils.py
index 34184a0224..bef44b1f97 100644
--- a/kpi/model_utils.py
+++ b/kpi/model_utils.py
@@ -1,7 +1,7 @@
 import contextlib
 import copy
 import re
-import logging
+
 from django.apps import apps
 from django.db.models import Q
 from django.contrib.contenttypes.models import ContentType
@@ -13,6 +13,7 @@
 from .models.object_permission import perm_parse
 from .haystack_utils import update_object_in_search_index
 
+
 '''
 This circular import will bite you if you don't import kpi.models before
 importing kpi.model_utils:
diff --git a/kpi/models/asset.py b/kpi/models/asset.py
index e028100edc..06fcbe5dc2 100644
--- a/kpi/models/asset.py
+++ b/kpi/models/asset.py
@@ -6,7 +6,6 @@
 import sys
 import copy
 import json
-import logging
 import StringIO
 from collections import OrderedDict
 
@@ -59,6 +58,7 @@
 from ..deployment_backends.mixin import DeployableMixin
 from kobo.apps.reports.constants import (SPECIFIC_REPORTS_KEY,
                                          DEFAULT_REPORTS_KEY)
+from kpi.utils.log import logging
 
 
 # TODO: Would prefer this to be a mixin that didn't derive from `Manager`.
@@ -748,6 +748,14 @@ def _snapshot(self, regenerate=True):
     def __unicode__(self):
         return u'{} ({})'.format(self.name, self.uid)
 
+    @property
+    def has_active_hooks(self):
+        """
+        Returns if asset has active hooks.
+        Useful to update `kc.XForm.has_kpi_hooks` field.
+        :return: {boolean}
+        """
+        return self.hooks.filter(active=True).exists()
     @staticmethod
     def optimize_queryset_for_list(queryset):
         ''' Used by serializers to improve performance when listing assets '''
diff --git a/kpi/models/import_export_task.py b/kpi/models/import_export_task.py
index 9acf93a396..e2a255f04a 100644
--- a/kpi/models/import_export_task.py
+++ b/kpi/models/import_export_task.py
@@ -1,7 +1,6 @@
 import re
 import pytz
 import base64
-import logging
 import datetime
 import requests
 import tempfile
@@ -27,9 +26,11 @@
 
 from ..fields import KpiUidField
 from ..models import Collection, Asset
+from ..deployment_backends.mock_backend import MockDeploymentBackend
 from ..zip_importer import HttpContentParse
 from ..model_utils import create_assets, _load_library_content, \
                           remove_string_prefix
+from kpi.utils.log import logging
 
 
 def utcnow(*args, **kwargs):
@@ -516,10 +517,10 @@ def _run_task(self, messages):
         # Take this opportunity to do some housekeeping
         self.log_and_mark_stuck_as_errored(self.user, source_url)
 
-        if hasattr(source.deployment, '_get_submissions'):
+        if isinstance(source.deployment, MockDeploymentBackend):
             # Currently used only for unit testing (`MockDeploymentBackend`)
             # TODO: Have the KC backend also implement `_get_submissions()`?
-            submission_stream = source.deployment._get_submissions()
+            submission_stream = source.deployment.get_submissions()
         else:
             submission_stream = None
 
diff --git a/kpi/renderers.py b/kpi/renderers.py
index e3e5cd5ec3..d30e7eb497 100644
--- a/kpi/renderers.py
+++ b/kpi/renderers.py
@@ -1,9 +1,7 @@
-from rest_framework import renderers
-from kpi.serializers import UserSerializer
-from kpi.models import AssetSnapshot
-
 import json
 
+from rest_framework import renderers
+
 
 class AssetJsonRenderer(renderers.JSONRenderer):
     media_type = 'application/json'
diff --git a/kpi/serializers.py b/kpi/serializers.py
index 032ea7d742..6d45058281 100644
--- a/kpi/serializers.py
+++ b/kpi/serializers.py
@@ -14,7 +14,7 @@
 from django.utils.six.moves.urllib import parse as urlparse
 from django.conf import settings
 from rest_framework import serializers, exceptions
-from rest_framework.pagination import LimitOffsetPagination
+from rest_framework.pagination import LimitOffsetPagination, PageNumberPagination
 from rest_framework.reverse import reverse_lazy, reverse
 from taggit.models import Tag
 
@@ -51,6 +51,13 @@ def get_parent_url(self, obj):
         return reverse_lazy('api-root', request=self.context.get('request'))
 
 
+class TinyPaginated(PageNumberPagination):
+    """
+    Same as Paginated with a small page size
+    """
+    page_size = 50
+
+
 class WritableJSONField(serializers.Field):
 
     """ Serializer for JSONField -- required to make field writable"""
@@ -519,6 +526,9 @@ class AssetSerializer(serializers.HyperlinkedModelSerializer):
     deployment__data_download_links = serializers.SerializerMethodField()
     deployment__submission_count = serializers.SerializerMethodField()
 
+    # Only add link instead of hooks list to avoid multiple access to DB.
+    hooks_link = serializers.SerializerMethodField()
+
     class Meta:
         model = Asset
         lookup_field = 'uid'
@@ -552,6 +562,7 @@ class Meta:
                   'embeds',
                   'koboform_link',
                   'xform_link',
+                  'hooks_link',
                   'tag_string',
                   'uid',
                   'kind',
@@ -613,6 +624,9 @@ def get_xls_link(self, obj):
     def get_xform_link(self, obj):
         return reverse('asset-xform', args=(obj.uid,), request=self.context.get('request', None))
 
+    def get_hooks_link(self, obj):
+        return reverse('hook-list', args=(obj.uid,), request=self.context.get('request', None))
+
     def get_embeds(self, obj):
         request = self.context.get('request', None)
 
diff --git a/kpi/signals.py b/kpi/signals.py
index 4528a9e979..ba09eea812 100644
--- a/kpi/signals.py
+++ b/kpi/signals.py
@@ -1,11 +1,14 @@
-from  django.db import models
+# -*- coding: utf-8 -*-
+from django.db.models.signals import post_save, post_delete
 from django.dispatch import receiver
 from django.contrib.auth.models import User
+
+from kobo.apps.hook.models.hook import Hook
 from taggit.models import Tag
 from .models import TagUid
 from .model_utils import grant_default_model_level_perms
 
-@receiver(models.signals.post_save, sender=User)
+@receiver(post_save, sender=User)
 def default_permissions_post_save(sender, instance, created, raw, **kwargs):
     '''
     Users must have both model-level and object-level permissions to satisfy
@@ -22,9 +25,19 @@ def default_permissions_post_save(sender, instance, created, raw, **kwargs):
         return
     grant_default_model_level_perms(instance)
 
-@receiver(models.signals.post_save, sender=Tag)
+@receiver(post_save, sender=Tag)
 def tag_uid_post_save(sender, instance, created, raw, **kwargs):
     ''' Make sure we have a TagUid object for each newly-created Tag '''
     if raw or not created:
         return
     TagUid.objects.get_or_create(tag=instance)
+
+
+@receiver([post_save, post_delete], sender=Hook)
+def update_kc_xform_has_kpi_hooks(sender, instance, **kwargs):
+    """
+    Updates `kc.XForm` instance as soon as Asset.Hook list is updated.
+    """
+    asset = instance.asset
+    if asset.has_deployment:
+        asset.deployment.set_has_kpi_hooks()
\ No newline at end of file
diff --git a/kpi/tests/kpi_test_case.py b/kpi/tests/kpi_test_case.py
index 727a86203e..344a138e8d 100644
--- a/kpi/tests/kpi_test_case.py
+++ b/kpi/tests/kpi_test_case.py
@@ -68,7 +68,7 @@ def create_asset(self, name, content=None, owner=None,
                      owner_password=None, **kwargs):
         if owner and owner_password:
             if isinstance(owner, basestring):
-                self.login(owner.username, owner_password)
+                self.login(owner, owner_password)
             self.login(owner.username, owner_password)
 
         if content is None:
@@ -80,7 +80,7 @@ def create_asset(self, name, content=None, owner=None,
             "asset_type": kwargs.get("asset_type", "survey")
         })
 
-        response= self.client.post(reverse('asset-list'), kwargs)
+        response = self.client.post(reverse('asset-list'), kwargs)
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
 
         if owner and owner_password:
diff --git a/kpi/tests/test_mock_data.py b/kpi/tests/test_mock_data.py
index 7b6e401e4c..6af34479b1 100644
--- a/kpi/tests/test_mock_data.py
+++ b/kpi/tests/test_mock_data.py
@@ -100,7 +100,7 @@ def setUp(self):
         schemas = [v.to_formpack_schema() for v in self.asset.deployed_versions]
         self.fp = FormPack(versions=schemas, id_string=self.asset.uid)
         self.vs = self.fp.versions.keys()
-        self.submissions = self.asset.deployment._get_submissions()
+        self.submissions = self.asset.deployment.get_submissions()
 
     def test_kobo_apps_reports_report_data(self):
         values = report_data.data_by_identifiers(self.asset,
@@ -172,7 +172,7 @@ def test_kobo_apps_reports_report_data_translation(self):
                           u'\u0627\u0644\u062b\u0627\u0646\u064a'))
 
     def test_export_works_if_no_version_value_provided_in_submission(self):
-        submissions = self.asset.deployment._get_submissions()
+        submissions = self.asset.deployment.get_submissions()
 
         for submission in submissions:
             del submission['__version__']
@@ -206,7 +206,7 @@ def test_has_report_styles(self):
         self.assertTrue(self.asset.report_styles is not None)
 
     def test_formpack_results(self):
-        submissions = self.asset.deployment._get_submissions()
+        submissions = self.asset.deployment.get_submissions()
 
         def _get_autoreport_values(qname, key, lang=None, index=False):
             stats = OrderedDict(_get_stats_object(self.fp,
@@ -237,4 +237,4 @@ def _get_autoreport_values(qname, key, lang=None, index=False):
     def test_has_version_and_submissions(self):
         self.assertEqual(self.asset.asset_versions.count(), 2)
         self.assertTrue(self.asset.has_deployment)
-        self.assertEqual(self.asset.deployment._submission_count(), 4)
+        self.assertEqual(self.asset.deployment.submission_count, 4)
diff --git a/kpi/tests/test_mock_data_conflicting_version_exports.py b/kpi/tests/test_mock_data_conflicting_version_exports.py
index 2532b3b22f..42c2ad0506 100644
--- a/kpi/tests/test_mock_data_conflicting_version_exports.py
+++ b/kpi/tests/test_mock_data_conflicting_version_exports.py
@@ -31,7 +31,7 @@ def setUp(self):
         self.asset = Asset.objects.get(uid='axD3Wc8ZnfgLXBcURRt5fM')
         # To avoid cluttering the fixture, assign permissions here
         self.asset.assign_perm(self.user, 'view_submissions')
-        self.submissions = self.asset.deployment._get_submissions()
+        self.submissions = self.asset.deployment.get_submissions()
         self.submission_id_field = '_id'
         self.formpack, self.submission_stream = report_data.build_formpack(
             self.asset,
diff --git a/kpi/tests/test_mock_data_exports.py b/kpi/tests/test_mock_data_exports.py
index 6f47bc2fdf..9d478b6640 100644
--- a/kpi/tests/test_mock_data_exports.py
+++ b/kpi/tests/test_mock_data_exports.py
@@ -198,7 +198,7 @@ def setUp(self):
         self.asset.save(create_version=False)
         self.formpack, self.submission_stream = report_data.build_formpack(
             self.asset,
-            submission_stream=self.asset.deployment._get_submissions()
+            submission_stream=self.asset.deployment.get_submissions()
         )
 
     def run_csv_export_test(self, expected_lines, export_options=None):
diff --git a/kpi/tests/test_mongo_decoding.py b/kpi/tests/test_mongo_decoding.py
index 96f257f6e1..c8b5bdac0e 100644
--- a/kpi/tests/test_mongo_decoding.py
+++ b/kpi/tests/test_mongo_decoding.py
@@ -6,7 +6,16 @@
 from django.test import TestCase
 from django.conf import settings
 
-from kobo.apps.reports import report_data
+from kpi.utils.mongo_helper import MongoDecodingHelper
+
+
+def get_instances_from_mongo():
+    query = {'_deleted_at': {'$exists': False}}
+    instances = settings.MONGO_DB.instances.find(query)
+    return (
+        MongoDecodingHelper.to_readable_dict(instance)
+            for instance in instances
+    )
 
 
 class FakeMongoDB(object):
@@ -78,8 +87,7 @@ def test_decoding_base64_dots(self):
             'regular': '1.3'
         }]
         settings.MONGO_DB = FakeMongoDB(encoded_results)
-        decoded = list(report_data.get_instances_for_userform_id(
-            '_userform_id is ignored by FakeMongoDB'))
+        decoded = list(get_instances_from_mongo())
         expected_results = decoded_results
         self.assertEqual(decoded, expected_results)
 
@@ -144,7 +152,6 @@ def test_decoding_base64_dots_in_repeating_groups(self):
             'regular': '1.3'
         }]
         settings.MONGO_DB = FakeMongoDB(encoded_results)
-        decoded = list(report_data.get_instances_for_userform_id(
-            '_userform_id is ignored by FakeMongoDB'))
+        decoded = list(get_instances_from_mongo())
         expected_results = decoded_results
         self.assertEqual(decoded, expected_results)
diff --git a/kpi/urls.py b/kpi/urls.py
index 8fca8ec175..5933f30a1f 100644
--- a/kpi/urls.py
+++ b/kpi/urls.py
@@ -33,13 +33,14 @@
 from kpi.forms import RegistrationForm
 from hub.views import switch_builder
 from hub.models import ConfigurationFile
+from kobo.apps.hook.views import HookViewSet, HookLogViewSet
 
 # TODO: Give other apps their own `urls.py` files instead of importing their
 # views directly! See
 # https://docs.djangoproject.com/en/1.8/intro/tutorial03/#namespacing-url-names
 
 router = ExtendedDefaultRouter()
-asset_routes = router.register(r'assets', AssetViewSet)
+asset_routes = router.register(r'assets', AssetViewSet, base_name='asset')
 asset_routes.register(r'versions',
                       AssetVersionViewSet,
                       base_name='asset-version',
@@ -56,6 +57,17 @@
                       parents_query_lookups=['asset'],
                       )
 
+hook_routes = asset_routes.register(r'hooks',
+                      HookViewSet,
+                      base_name='hook',
+                      parents_query_lookups=['asset'],
+                      )
+
+hook_routes.register(r'logs',
+                     HookLogViewSet,
+                     base_name='hook-log',
+                     parents_query_lookups=['asset', 'hook'],
+                     )
 
 router.register(r'asset_snapshots', AssetSnapshotViewSet)
 router.register(
diff --git a/kpi/utils/log.py b/kpi/utils/log.py
new file mode 100644
index 0000000000..b338b86606
--- /dev/null
+++ b/kpi/utils/log.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+import logging as stdlib_logging
+
+def get_default_logger():
+    return stdlib_logging.getLogger("console_logger")
+
+# logging does not print to stdout when RAVEN/sentry is activated.
+# To avoid to call logging.getLogger everywhere, we overload logging
+logging = get_default_logger()
+
diff --git a/kpi/views.py b/kpi/views.py
index 63532a14ef..25f32ceaa3 100644
--- a/kpi/views.py
+++ b/kpi/views.py
@@ -104,8 +104,10 @@
     COLLECTION_CLONE_FIELDS, ASSET_TYPE_ARG_NAME, CLONE_COMPATIBLE_TYPES, \
     ASSET_TYPE_TEMPLATE, ASSET_TYPE_SURVEY, ASSET_TYPES
 from deployment_backends.backends import DEPLOYMENT_BACKENDS
-from deployment_backends.kobocat_backend import KobocatDataProxyViewSetMixin
+from deployment_backends.mixin import KobocatDataProxyViewSetMixin
+from kobo.apps.hook.utils import HookUtils
 from kpi.exceptions import BadAssetTypeException
+from kpi.utils.log import logging
 
 
 @login_required
@@ -701,10 +703,46 @@ class SubmissionViewSet(NestedViewSetMixin, viewsets.ViewSet,
                         KobocatDataProxyViewSetMixin):
     '''
     TODO: Access the submission data directly instead of merely proxying to
-    KoBoCAT
+    KoBoCAT. We can now use `KobocatBackend.get_submissions()` and
+     `KobocatBackend.get_submission()`
     '''
     parent_model = Asset
 
+    def create(self, request, *args, **kwargs):
+        """
+        This endpoint is handled by the SubmissionViewSet (not KobocatDataProxyViewSetMixin)
+        because it doesn't use KC proxy.
+        It's only used to trigger hook services of the Asset (so far).
+
+        :param request:
+        :return:
+        """
+        # Follow Open Rosa responses by default
+        response_status_code = status.HTTP_202_ACCEPTED
+        response = {
+            "detail": _(
+                "We got and saved your data, but may not have fully processed it. You should not try to resubmit.")
+        }
+        try:
+            asset_uid = self.get_parents_query_dict().get("asset")
+            asset = get_object_or_404(self.parent_model, uid=asset_uid)
+            instance_id = request.data.get("instance_id")
+            if not HookUtils.call_services(asset, instance_id):
+                response_status_code = status.HTTP_409_CONFLICT
+                response = {
+                    "detail": _(
+                        "Your data for instance {} has been already submitted.".format(instance_id))
+                }
+
+        except Exception as e:
+            logging.error("SubmissionViewSet.create - {}".format(str(e)))
+            response = {
+                "detail": _("An error has occurred when calling the external service. Please retry later.")
+            }
+            response_status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+
+        return Response(response, status=response_status_code)
+
 
 class AssetVersionViewSet(NestedViewSetMixin, viewsets.ModelViewSet):
     model = AssetVersion
@@ -725,7 +763,6 @@ def get_queryset(self):
         _queryset = self.model.objects.filter(asset__uid=_asset_uid)
         if _deployed is not None:
             _queryset = _queryset.filter(deployed=_deployed)
-        _queryset = _queryset.filter(asset__uid=_asset_uid)
         if self.action == 'list':
             # Save time by only retrieving fields from the DB that the
             # serializer will use