diff --git a/lib/modules/storage/index.js b/lib/modules/storage/index.js
index 80591b92b..1cefc429e 100644
--- a/lib/modules/storage/index.js
+++ b/lib/modules/storage/index.js
@@ -1,10 +1,4 @@
-
-const utils = require('../../utils/utils.js');
-const fs = require('../../core/fs.js');
 const _ = require('underscore');
-const async = require('async');
-const StorageProcessesLauncher = require('../../processes/storageProcesses/storageProcessesLauncher');
-const constants = require('../../constants');
 
 const IpfsModule = require('../ipfs');
 const SwarmModule = require('../swarm');
@@ -23,22 +17,8 @@ class Storage {
 
     if (!this._storageConfig.enabled) return;
 
-    // filter list of dapp connections based on available_providers set in config
-    let hasSwarm = _.contains(this._storageConfig.available_providers, 'swarm'); // don't need to eval this in every loop iteration
-    // contains valid dapp storage providers
-    this._validDappProviders = _.filter(this._storageConfig.dappConnection, (conn) => {
-      return _.contains(self._storageConfig.available_providers, conn.provider) || (conn === '$BZZ' && hasSwarm);
-    });
     this.addSetProviders();
 
-    //    this.initStorageForEmbark();
-    //    this.initStorageForDapp();
-
-    //    // don't start storage processes on build command, only on upload or run
-    //    if(_.contains(options.context, constants.contexts.upload) || _.contains(options.context, constants.contexts.run)){
-    //      this.startStorageProcesses();
-    //    }
-
     new IpfsModule(embark, options); /*eslint no-new: "off"*/
     new SwarmModule(embark, options); /*eslint no-new: "off"*/
 
@@ -51,162 +31,27 @@ class Storage {
     });
   }
 
-  _checkStorageEndpoint(platform, callback) {
-    let checkFn;
-    let self = this;
-    self._logger.trace(`Storage module: Checking ${platform} availability...`);
-    _.find(self._servicesMonitor.checkList, (value, key) => {
-      if(key.toLowerCase() === platform.toLowerCase()){
-        checkFn = value;
-        return true;
-      }
-    });
-    if (!checkFn || typeof checkFn.fn !== 'function') {
-      self._logger.trace(`Storage module: Check for ${platform} node does not exist.`);
-      return callback();
-    }
-
-    checkFn.fn(function (serviceCheckResult) {
-      if (!serviceCheckResult.status || serviceCheckResult.status === 'off') {
-        self._logger.trace(`Storage module: ${platform} node not available.`);
-        return callback('No node');
-      }
-      callback();
-    });
-  }
-
-  _startStorageNode(platform, callback) {
-    let self = this;
-    const storageProcessesLauncher = new StorageProcessesLauncher({
-      logger: self._logger,
-      events: self._events,
-      storageConfig: self._storageConfig,
-      webServerConfig: self._webServerConfig,
-      blockchainConfig: self._blockchainConfig
-    });
-    self._logger.trace(`Storage module: Launching ${platform} process...`);
-    return storageProcessesLauncher.launchProcess(platform.toLowerCase(), (err) => {
-      if (err) {
-        return callback(err);
-      }
-      callback();
-    });
-  }
-
-  /**
-   * Initializes a storage provider for EmbarkJS
-   * 
-   * @return {void}
-   */
-  initStorageForDapp(){
-    // now we need to add instantiate any dappConnection/available_providers storage providers to add
-    // their provider code to embarkjs
-    this._validDappProviders.forEach(dappConn => {
-      if(!dappConn.provider) return;
-      let storageProviderCls = require(`../${dappConn.provider}/index.js`);
-      
-      // override options with dappConnection settings
-      let storageOptions = this._options;
-      storageOptions.protocol = dappConn.protocol;
-      storageOptions.host = dappConn.host;
-      storageOptions.port = dappConn.port;
-
-      // then instantiate the storage provdier class
-      let storageProvider = new storageProviderCls(this._embark, storageOptions); /*eslint no-new: "off"*/
-
-      // register the service check so we can use it to check if the process is running before spawning it
-      // check that it hasn't already been done above
-      if(dappConn.provider !== this._storageConfig.upload.provider){
-        if(typeof storageProvider.setServiceCheck == 'function') storageProvider.setServiceCheck();
-      }
-
-      // add __embarkSwarm and __embarkIPFS objects to EmbarkJS
-      if(typeof storageProvider.addProviderToEmbarkJS == 'function') storageProvider.addProviderToEmbarkJS();
-    });
-
-    // add the code to call setProviders in embarkjs after embark is ready
-    this.addSetProviders();
-  }
-
   /**
    * Adds the code to call setProviders in embarkjs after embark is ready
    * 
    * @returns {void}
    */
   addSetProviders() {
+    // filter list of dapp connections based on available_providers set in config
+    let hasSwarm = _.contains(this._storageConfig.available_providers, 'swarm'); // don't need to eval this in every loop iteration
+    // contains valid dapp storage providers
+    this._validDappProviders = _.filter(this._storageConfig.dappConnection, (conn) => {
+      return _.contains(self._storageConfig.available_providers, conn.provider) || (conn === '$BZZ' && hasSwarm);
+    });
+
     let code = `\nEmbarkJS.Storage.setProviders(${JSON.stringify(this._validDappProviders)});`;
     let shouldInit = (storageConfig) => {
       return (this._validDappProviders !== undefined && this._validDappProviders.length > 0 && storageConfig.enabled === true);
     };
-  
+
     this._embark.addProviderInit('storage', code, shouldInit);
   }
 
-  checkStorageService(platform, url, callback) {
-    const self = this;
-
-    // start the upload storage node
-    self._checkStorageEndpoint(platform, function (err) {
-      if (!err) {
-        return callback(null);
-      }
-      self._startStorageNode(platform, (err) => {
-        if (err) {
-          return callback(err);
-        }
-        // Check endpoint again to see if really did start
-        self._checkStorageEndpoint(platform, (err) => {
-          if (err) {
-            return callback(err);
-          }
-          callback(null);
-        });
-      });
-    });
-  }
-
-  startStorageProcesses(){
-    let platform = this._storageConfig.upload.provider;
-    let self = this;
-    let withErrors = false;
-
-    async.waterfall([
-      function _checkStorageService(callback){
-        self.checkStorageService(platform, utils.buildUrlFromConfig(self._storageConfig.upload), (err) => {
-          // log error and continue
-          if(err){
-            self._logger.error(err);
-            withErrors = true;
-          }
-          callback(null);
-        });
-      },
-      function checkDappConnectionStorageService(callback){
-        // start any dappConnection storage nodes
-        async.each(self._validDappProviders, function(dappConn, cb) {
-          if(!dappConn.provider || dappConn.provider === platform) {
-            return cb(null);
-          } // don't start the process we've just started above
-
-          self.checkStorageService(dappConn.provider, utils.buildUrlFromConfig(dappConn), (err) => {
-            // log error and continue
-            if(err){
-              self._logger.error(err);
-              withErrors = true;
-            }
-            cb(null);
-          });
-        }, callback);
-      }
-    ], function (){
-      let strComplete = __('Finished starting all storage providers');
-      if(withErrors){
-        strComplete += ', ' + __('with errors.');
-        return self._logger.warn(strComplete);
-      }
-      self._logger.info(strComplete + '.');
-    });
-  }
 }
 
 module.exports = Storage;