diff --git a/src/ui/public/courier/fetch/fetch_now.js b/src/ui/public/courier/fetch/fetch_now.js
index 73a670100cece..7bb3890fbf95e 100644
--- a/src/ui/public/courier/fetch/fetch_now.js
+++ b/src/ui/public/courier/fetch/fetch_now.js
@@ -22,7 +22,6 @@ import { CallClientProvider } from './call_client';
 import { CallResponseHandlersProvider } from './call_response_handlers';
 import { ContinueIncompleteProvider } from './continue_incomplete';
 import { RequestStatus } from './req_status';
-import { location } from './notifier';
 
 /**
  * Fetch now provider should be used if you want the results searched and returned immediately.
@@ -53,7 +52,10 @@ export function FetchNowProvider(Private, Promise) {
 
       return searchRequest.retry();
     }))
-      .catch(error => fatalError(error, location));
+      .catch(error => {
+        // If any errors occur after the search requests have resolved, then we kill Kibana.
+        fatalError(error, 'Courier fetch');
+      });
   }
 
   function fetchSearchResults(searchRequests) {
@@ -71,7 +73,11 @@ export function FetchNowProvider(Private, Promise) {
     return startRequests(searchRequests)
       .then(function () {
         replaceAbortedRequests();
-        return callClient(searchRequests);
+        return callClient(searchRequests)
+          .catch(() => {
+            // Silently swallow errors that result from search requests so the consumer can surface
+            // them as notifications instead of courier forcing fatal errors.
+          });
       })
       .then(function (responses) {
         replaceAbortedRequests();
diff --git a/src/ui/public/courier/index.js b/src/ui/public/courier/index.js
index d466b2e080e3f..583172f1731cd 100644
--- a/src/ui/public/courier/index.js
+++ b/src/ui/public/courier/index.js
@@ -30,6 +30,8 @@ export {
 } from './search_source';
 
 export {
+  addSearchStrategy,
   hasSearchStategyForIndexPattern,
   isDefaultTypeIndexPattern,
+  SearchError,
 } from './search_strategy';
diff --git a/src/ui/public/courier/search_strategy/default_search_strategy.js b/src/ui/public/courier/search_strategy/default_search_strategy.js
index 05fc45c5c67d1..f5bd529b35c0b 100644
--- a/src/ui/public/courier/search_strategy/default_search_strategy.js
+++ b/src/ui/public/courier/search_strategy/default_search_strategy.js
@@ -19,6 +19,7 @@
 
 import { addSearchStrategy } from './search_strategy_registry';
 import { isDefaultTypeIndexPattern } from './is_default_type_index_pattern';
+import { SearchError } from './search_error';
 
 function getAllFetchParams(searchRequests, Promise) {
   return Promise.map(searchRequests, (searchRequest) => {
@@ -71,14 +72,30 @@ export const defaultSearchStrategy = {
     const searching = es.msearch({ body: serializedFetchParams });
 
     return {
-      // Unwrap the responses object returned by the es client.
-      searching: searching.then(({ responses }) => responses),
+      // Munge data into shape expected by consumer.
+      searching: new Promise((resolve, reject) => {
+        // Unwrap the responses object returned by the ES client.
+        searching.then(({ responses }) => {
+          resolve(responses);
+        }).catch(error => {
+          // Format ES client error as a SearchError.
+          const { statusCode, displayName, message, path } = error;
+
+          const searchError = new SearchError({
+            status: statusCode,
+            title: displayName,
+            message,
+            path,
+          });
+
+          reject(searchError);
+        });
+      }),
       abort: searching.abort,
       failedSearchRequests,
     };
   },
 
-  // Accept multiple criteria for determining viability to be as flexible as possible.
   isViable: (indexPattern) => {
     if (!indexPattern) {
       return false;
diff --git a/src/ui/public/courier/search_strategy/index.js b/src/ui/public/courier/search_strategy/index.js
index 41991b63f950d..102610538df98 100644
--- a/src/ui/public/courier/search_strategy/index.js
+++ b/src/ui/public/courier/search_strategy/index.js
@@ -24,3 +24,5 @@ export {
 } from './search_strategy_registry';
 
 export { isDefaultTypeIndexPattern } from './is_default_type_index_pattern';
+
+export { SearchError } from './search_error';
diff --git a/src/ui/public/courier/search_strategy/search_error.js b/src/ui/public/courier/search_strategy/search_error.js
new file mode 100644
index 0000000000000..fecafb9b6fc13
--- /dev/null
+++ b/src/ui/public/courier/search_strategy/search_error.js
@@ -0,0 +1,34 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export class SearchError extends Error {
+  constructor({ status, title, message, path }) {
+    super(message);
+    this.name = 'SearchError';
+    this.status = status;
+    this.title = title;
+    this.message = message;
+    this.path = path;
+    Error.captureStackTrace(this, SearchError);
+
+    // Babel doesn't support traditional `extends` syntax for built-in classes.
+    // https://babeljs.io/docs/en/caveats/#classes
+    Object.setPrototypeOf(this, SearchError.prototype);
+  }
+}
diff --git a/src/ui/public/courier/search_strategy/search_strategy_registry.js b/src/ui/public/courier/search_strategy/search_strategy_registry.js
index d6df4bea2d741..79e959b2a80ad 100644
--- a/src/ui/public/courier/search_strategy/search_strategy_registry.js
+++ b/src/ui/public/courier/search_strategy/search_strategy_registry.js
@@ -52,7 +52,6 @@ export const assignSearchRequestsToSearchStrategies = searchRequests => {
   const searchStrategyById = {};
 
   searchRequests.forEach(searchRequest => {
-
     const indexPattern = searchRequest.source.getField('index');
     const matchingSearchStrategy = getSearchStrategy(indexPattern);
 
diff --git a/src/ui/public/vis/editors/default/sidebar.html b/src/ui/public/vis/editors/default/sidebar.html
index f0cff4acd142f..43ddf5e1aff21 100644
--- a/src/ui/public/vis/editors/default/sidebar.html
+++ b/src/ui/public/vis/editors/default/sidebar.html
@@ -19,6 +19,15 @@
     </div>
 
     <nav class="navbar navbar-default subnav">
+      <div class="visEditorSidebarError" ng-if="sidebar.persistentError">
+        <call-out
+          color="'danger'"
+          iconType="'alert'"
+          title="sidebar.persistentError"
+          size="'s'"
+        />
+      </div>
+
       <div class="container-fluid">
 
         <!-- tabs -->
diff --git a/src/ui/public/vis/editors/default/sidebar.js b/src/ui/public/vis/editors/default/sidebar.js
index 6503a11b998f1..96bd4f755ea2d 100644
--- a/src/ui/public/vis/editors/default/sidebar.js
+++ b/src/ui/public/vis/editors/default/sidebar.js
@@ -23,17 +23,18 @@ import './vis_options';
 import { uiModules } from '../../../modules';
 import sidebarTemplate from './sidebar.html';
 
+import './sidebar.less';
+
 uiModules
   .get('app/visualize')
   .directive('visEditorSidebar', function () {
-
-
     return {
       restrict: 'E',
       template: sidebarTemplate,
       scope: true,
       controllerAs: 'sidebar',
       controller: function ($scope) {
+        this.persistentError = undefined;
 
         $scope.$watch('vis.type', (visType) => {
           if (visType) {
@@ -49,6 +50,21 @@ uiModules
             this.section = this.section || (this.showData ? 'data' : _.get(visType, 'editorConfig.optionTabs[0].name'));
           }
         });
+
+        // TODO: This doesn't update when requestError is set.
+        $scope.$watch('vis.requestError', (requestError) => {
+          if (requestError && requestError.messsage) {
+            const { message } = requestError;
+            const isRollupError = message.includes('rollup');
+
+            if (isRollupError) {
+              this.persistentError = message;
+              return;
+            }
+          }
+
+          this.persistentError = undefined;
+        });
       }
     };
   });
diff --git a/src/ui/public/vis/editors/default/sidebar.less b/src/ui/public/vis/editors/default/sidebar.less
new file mode 100644
index 0000000000000..9e346211e073f
--- /dev/null
+++ b/src/ui/public/vis/editors/default/sidebar.less
@@ -0,0 +1,3 @@
+.visEditorSidebarError {
+  padding: 8px;
+}
diff --git a/src/ui/public/visualize/loader/visualize_data_loader.js b/src/ui/public/visualize/loader/visualize_data_loader.js
index 3cd5d5472aa70..4ddf1ba235093 100644
--- a/src/ui/public/visualize/loader/visualize_data_loader.js
+++ b/src/ui/public/visualize/loader/visualize_data_loader.js
@@ -16,6 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
+import React, { Fragment } from 'react';
 import { isEqual } from 'lodash';
 import { VisRequestHandlersRegistryProvider } from '../../registry/vis_request_handlers';
 import { VisResponseHandlersRegistryProvider } from '../../registry/vis_response_handlers';
@@ -25,6 +27,7 @@ import {
 } from '../../elasticsearch_errors';
 
 import { toastNotifications } from 'ui/notify';
+import { SearchError } from 'ui/courier';
 
 function getHandler(from, name) {
   if (typeof name === 'function') return name;
@@ -62,24 +65,41 @@ export class VisualizeDataLoader {
 
       this._previousVisState = this._vis.getState();
       this._previousRequestHandlerResponse = requestHandlerResponse;
+      this._vis.requestError = undefined;
 
       if (!canSkipResponseHandler) {
         this._visData = await Promise.resolve(this._responseHandler(this._vis, requestHandlerResponse));
       }
       return this._visData;
     }
-    catch (e) {
+    catch (error) {
       props.searchSource.cancelQueued();
-      this._vis.requestError = e;
-      if (isTermSizeZeroError(e)) {
-        return toastNotifications.addDanger(
-          `Your visualization ('${props.vis.title}') has an error: it has a term ` +
-          `aggregation with a size of 0. Please set it to a number greater than 0 to resolve ` +
-          `the error.`
-        );
+      this._vis.requestError = error;
+
+      if (isTermSizeZeroError(error)) {
+        return toastNotifications.addDanger({
+          title: `Visualization ('${this._vis.title}') has term aggregation of size 0`,
+          text: `Set it to a size greater than 0`,
+        });
+      }
+
+      if (error instanceof SearchError) {
+        const { message, path, status } = error;
+        return toastNotifications.addDanger({
+          title: `Visualization '${this._vis.title}' search failed`,
+          text: (
+            <Fragment>
+              <p>{message}</p>
+              <p><code>{status} {path}</code></p>
+            </Fragment>
+          ),
+        });
       }
-      toastNotifications.addDanger(e);
+
+      toastNotifications.addDanger({
+        title: `Visualization '${this._vis.title}' has an error`,
+        text: error,
+      });
     }
   }
-
 }
diff --git a/x-pack/plugins/rollup/index.js b/x-pack/plugins/rollup/index.js
index 8c3c949ed3137..2f91455c91288 100644
--- a/x-pack/plugins/rollup/index.js
+++ b/x-pack/plugins/rollup/index.js
@@ -9,7 +9,7 @@ import { PLUGIN } from './common/constants';
 import { registerLicenseChecker } from './server/lib/register_license_checker';
 import { registerIndicesRoute, registerFieldsForWildcardRoute, registerSearchRoute } from './server/routes/api';
 
-export function rollup(kibana)  {
+export function rollup(kibana) {
   return new kibana.Plugin({
     id: PLUGIN.ID,
     publicDir: resolve(__dirname, 'public'),
diff --git a/x-pack/plugins/rollup/public/search/rollup_search_strategy.js b/x-pack/plugins/rollup/public/search/rollup_search_strategy.js
index 55c405593a8a5..37e61ad00fa15 100644
--- a/x-pack/plugins/rollup/public/search/rollup_search_strategy.js
+++ b/x-pack/plugins/rollup/public/search/rollup_search_strategy.js
@@ -4,6 +4,9 @@
 * you may not use this file except in compliance with the Elastic License.
 */
 
+import { kfetchAbortable } from 'ui/kfetch';
+import { SearchError } from 'ui/courier';
+
 export const rollupSearchStrategy = {
   id: 'rollup',
 
@@ -18,39 +21,94 @@ export const rollupSearchStrategy = {
       },
     } = await searchRequest.getFetchParams();
 
+    function findDateHistogram(aggs) {
+      if (Array.isArray(aggs)) {
+        for (let i = 0; i < aggs.length; i++) {
+          const dateHistogram = findDateHistogram(aggs[i]);
+
+          if (dateHistogram) {
+            return dateHistogram;
+          }
+        }
+      } else if (typeof aggs === 'object') {
+        const aggNames = Object.keys(aggs);
+        const aggsList = aggNames.map(aggName => aggs[aggName]);
+
+        if (aggsList.includes('date_histogram')) {
+          return aggs;
+        }
+
+        return findDateHistogram(aggsList);
+      }
+    }
+
+    // TODO: Temporarily automatically assign same timezone and interval as what's defined by
+    // the rollup job. This should be done by the visualization itself.
+    const searchableAggs = JSON.parse(searchRequest.source.getField('index').originalBody.typeMeta);
+    const { time_zone: timeZone, interval } = findDateHistogram(searchableAggs);
+
+    Object.keys(aggs).forEach(aggName => {
+      const subAggs = aggs[aggName];
+
+      Object.keys(subAggs).forEach(subAggName => {
+        if (subAggName === 'date_histogram') {
+          const subAgg = subAggs[subAggName];
+          subAgg.time_zone = timeZone;
+          subAgg.interval = interval;
+        }
+      });
+    });
+
     const index = indexPattern;
     const query = {
       'size': size,
       'aggregations': aggs,
     };
 
-    // TODO: Handle errors gracefully and surface them to the user.
-    return new Promise((resolve, reject) => {
-      fetch('../api/rollup/search', {
-        method: 'post',
-        body: JSON.stringify({ index, query }),
-        headers: {
-          accept: 'application/json',
-          'content-type': 'application/json',
-          'kbn-xsrf': 'kibana',
-        },
-        credentials: 'same-origin'
-      }).then(response => {
-        return response.json();
-      }).then(data => {
-        // Munge data into shape expected by consumer.
-        resolve({
-          took: data.took,
-          responses: [ data ],
-        });
-      }).catch(error => {
-        return reject(error);
-      });
+    const {
+      fetching,
+      abort,
+    } = kfetchAbortable({
+      pathname: '../api/rollup/search',
+      method: 'POST',
+      body: JSON.stringify({ index, query }),
     });
+
+    // TODO: Implement this. Search requests which can't be sent.
+    const failedSearchRequests = [];
+
+    return {
+      // Munge data into shape expected by consumer.
+      searching: new Promise((resolve, reject) => {
+        fetching.then(result => {
+          resolve([ result ]);
+        }).catch(error => {
+          const {
+            body: { statusText, error: title, message },
+            res: { url },
+          } = error;
+
+          // Format kfetch error as a SearchError.
+          const searchError = new SearchError({
+            status: statusText,
+            title,
+            message,
+            path: url,
+          });
+
+          reject(searchError);
+        });
+      }),
+      abort,
+      failedSearchRequests,
+    };
   },
 
-  isValidForSearchRequest: searchRequest => {
-    const indexPattern = searchRequest.source.getField('index');
+  isViable: (indexPattern) => {
+    if (!indexPattern) {
+      return false;
+    }
+
     return indexPattern.type === 'rollup';
   },
 };