diff --git a/README.md b/README.md
index 81b9cc8e93..2bc9de8a8a 100644
--- a/README.md
+++ b/README.md
@@ -196,7 +196,25 @@ The HTTP-API exposed by the js-ipfs daemon follows the [`http-api-spec`](https:/
 
 #### Create a IPFS node instance
 
-The basic startup flow involves (optionally) creating a Repo, creating an IPFS node, `init`-ing it so it can generate its keys, `load`-ing its configuration, and putting it online with `goOnline`. Here is a structural example:
+Creating an IPFS instance couldn't be easier, all you have to do is:
+
+```JavaScript
+// Create the IPFS node instance
+const node = new IPFS()
+
+node.on('start', () => {
+  // Your now is ready to use \o/
+
+  // stopping a node
+  node.stop(() => {
+    // node is now 'offline'
+  })
+})
+```
+
+#### Advanced options when creating an IPFS node.
+
+When starting a node, you can:
 
 ```JavaScript
 // IPFS will need a repo, it can create one for you or you can pass
@@ -204,38 +222,28 @@ The basic startup flow involves (optionally) creating a Repo, creating an IPFS n
 // https://github.com/ipfs/js-ipfs-repo
 const repo = <IPFS Repo instance or repo path>
 
-// Create the IPFS node instance
 const node = new IPFS({
   repo: repo,
-  EXPERIMENTAL: {
-    pubsub: false
+  init: true, // default
+  // init: false,
+  // init: {
+  //   bits: 1024 // size of the RSA key generated
+  // },
+  start: true,
+  // start: false,
+  EXPERIMENTAL: { // enable experimental features
+    pubsub: true
+  },
+  config: { // overload the default config
+    Addresses: {
+      Swarm: [
+        '/ip4/127.0.0.1/tcp/1337'
+      ]
+    }
   }
 })
-
-// We need to init our repo, in this case the repo was empty
-// We are picking 2048 bits for the RSA key that will be our PeerId
-node.init({ emptyRepo: true, bits: 2048 }, (err) => {
-   if (err) { throw err }
-
-   // Once the repo is initiated, we have to load it so that the IPFS
-   // instance has its config values. This is useful when you have
-   // previous created repos and you don't need to generate a new one
-   node.load((err) => {
-     if (err) { throw err }
-
-     // Last but not the least, we want our IPFS node to use its peer
-     // connections to fetch and serve blocks from.
-     node.goOnline((err) => {
-       if (err) { throw err }
-       // Here you should be good to go and call any IPFS function
-   })
-})
 ```
 
-> We are working on making this init process better, see https://github.com/ipfs/js-ipfs/issues/556 for the discussion.
-
-More examples can be found in the [examples folder](./examples)
-
 ### [Tutorials and Examples](/examples)
 
 You can find some examples and tutorials in the [examples](/examples) folder, these exist to help you get started using `js-ipfs`.
diff --git a/examples/basics/index.js b/examples/basics/index.js
index 824e4001fc..21fc7929e4 100644
--- a/examples/basics/index.js
+++ b/examples/basics/index.js
@@ -14,6 +14,8 @@ const IPFS = require('../../src/core')
  */
 const node = new IPFS({
   repo: path.join(os.tmpdir() + '/' + new Date().toString()),
+  init: false,
+  start: false,
   EXPERIMENTAL: {
     pubsub: false
   }
@@ -42,14 +44,10 @@ series([
    * Initialize the repo for this node
    */
   (cb) => node.init({ emptyRepo: true, bits: 2048 }, cb),
-  /*
-   * Load the repo config into the IPFS node
-   */
-  (cb) => node.load(cb),
   /*
    * Take the node online (bitswap, network and so on)
    */
-  (cb) => node.goOnline(cb),
+  (cb) => node.start(cb),
   /*
    * Add a file to IPFS - Complete Files API on:
    * https://github.com/ipfs/interface-ipfs-core/tree/master/API/files
diff --git a/examples/browser-script-tag/index.html b/examples/browser-script-tag/index.html
index f51b0d5286..76639158e8 100644
--- a/examples/browser-script-tag/index.html
+++ b/examples/browser-script-tag/index.html
@@ -4,15 +4,12 @@
   <title>IPFS in the Browser</title>
   <script src="https://unpkg.com/ipfs/dist/index.min.js"></script>
   <script type="text/javascript">
-    // We provide a hosted signalling endpoint that you can use to discover
-    // and dial to other nodes. It is hosted at `star-signal.cloud.ipfs.team`
-    // If you run your own signalling, you can change this multiaddr.
-    const SIGNALING_SERVER = '/libp2p-webrtc-star/dns4/star-signal.cloud.ipfs.team/wss/ipfs/'
-
     const repoPath = 'ipfs-' + Math.random()
 
     // Create an IPFS node
     const node = new Ipfs({
+      init: false,
+      start: false
       repo: repoPath
     })
 
@@ -20,35 +17,15 @@
     node.init(handleInit)
 
     function handleInit (err) {
-      if (!err) { // The repo was initialized for the first time, we need to configure it
-        addWebRTCMultiaddr()
-      } else if (err && err.message !== 'repo already exists') { // The repo already existed, let's just load it
-        loadRepo()
-      } else {
+      if (err) {
         throw err
       }
-    }
-
-    function addWebRTCMultiaddr() {
-      // Addj the WebrTCStar Multiaddr to your node
-      node.config.get(function (err, config) {
-        if (err) {
-          throw err
-        }
-
-        const starAddr = (SIGNALING_SERVER + config.Identity.PeerID)
-
-        node.config.set('Addresses.Swarm[1]', starAddr, loadRepo)
-      })
-    }
 
-    function loadRepo() {
-      node.load(() => node.goOnline(() => {
+      node.start(() => {
         console.log('Online status: ', node.isOnline() ? 'online' : 'offline')
 
         document.getElementById("status").innerHTML= 'Node status: ' + (node.isOnline() ? 'online' : 'offline')
 
-        // \o/ Now you have an IPFS node using WebRTC to find other nodes!
         // You can write more code here to use it. Use methods like 
         // node.files.add, node.files.get. See the API docs here:
         // https://github.com/ipfs/interface-ipfs-core/tree/master/API
diff --git a/examples/bundle-browserify/src/index.js b/examples/bundle-browserify/src/index.js
index ac187e5c8b..7e3189cb4f 100644
--- a/examples/bundle-browserify/src/index.js
+++ b/examples/bundle-browserify/src/index.js
@@ -11,6 +11,8 @@ const repoPath = String(Math.random())
 
 const node = new IPFS({
   repo: repoPath,
+  init: false,
+  start: false,
   EXPERIMENTAL: {
     pubsub: false
   }
@@ -23,17 +25,12 @@ node.init({ emptyRepo: true, bits: 2048 }, function (err) {
   if (err) {
     throw err
   }
-  node.load(function (err) {
+
+  node.start(function (err) {
     if (err) {
       throw err
     }
-
-    node.goOnline(function (err) {
-      if (err) {
-        throw err
-      }
-      console.log('IPFS node is ready')
-    })
+    console.log('IPFS node is ready')
   })
 })
 
diff --git a/examples/bundle-webpack/src/components/app.js b/examples/bundle-webpack/src/components/app.js
index 0b84e6404d..43b9d1f983 100644
--- a/examples/bundle-webpack/src/components/app.js
+++ b/examples/bundle-webpack/src/components/app.js
@@ -29,8 +29,11 @@ class App extends React.Component {
       // for simplicity, we create a new repo everytime the node
       // is created, because you can't init already existing repos
       const repoPath = String(Math.random())
+
       node = new IPFS({
         repo: repoPath,
+        init: false,
+        start: false,
         EXPERIMENTAL: {
           pubsub: false
         }
@@ -40,18 +43,13 @@ class App extends React.Component {
         if (err) {
           throw err
         }
-        node.load(function (err) {
+
+        node.start(function (err) {
           if (err) {
             throw err
           }
-
-          node.goOnline(function (err) {
-            if (err) {
-              throw err
-            }
-            console.log('IPFS node is ready')
-            ops()
-          })
+          console.log('IPFS node is ready')
+          ops()
         })
       })
     }
diff --git a/examples/dag/create-node.js b/examples/dag/create-node.js
index e95f602bbc..18287e49c1 100644
--- a/examples/dag/create-node.js
+++ b/examples/dag/create-node.js
@@ -1,7 +1,5 @@
 'use strict'
 
-const series = require('async/series')
-
 const IPFS = require('../../src/core')
 // In your project, replace by the following line and install IPFS as a dep
 // const IPFS = require('ipfs')
@@ -18,11 +16,7 @@ function createNode (options, callback) {
     repo: options.path
   })
 
-  series([
-    (cb) => node.init({ emptyRepo: true, bits: 2048 }, cb),
-    (cb) => node.load(cb),
-    (cb) => node.goOnline(cb)
-  ], (err) => callback(err, node))
+  node.on('start', () => callback(null, node))
 }
 
 module.exports = createNode
diff --git a/gulpfile.js b/gulpfile.js
index 0138ab4be7..5f103386ce 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -16,42 +16,37 @@ let nodes = []
 function spawnDaemon (num, callback) {
   num = leftPad(num, 3, 0)
 
-  const repo = createTempRepo()
-
   const node = new IPFS({
-    repo: repo,
+    repo: createTempRepo(),
+    init: {
+      bits: 1024
+    },
+    start: false,
     EXPERIMENTAL: {
       pubsub: true
+    },
+    config: {
+      Addresses: {
+        Swarm: [
+          `/ip4/127.0.0.1/tcp/10${num}`,
+          `/ip4/127.0.0.1/tcp/20${num}/ws`
+        ],
+        API: `/ip4/127.0.0.1/tcp/31${num}`,
+        Gateway: `/ip4/127.0.0.1/tcp/32${num}`
+      },
+      Discovery: {
+        MDNS: {
+          Enabled: false
+        }
+      }
     }
   })
 
-  series([
-    (cb) => node.init({ emptyRepo: true, bits: 1024 }, cb),
-    (cb) => {
-      repo.config.get((err, config) => {
-        if (err) { return callback(err) }
-
-        config.Addresses = {
-          Swarm: [
-            `/ip4/127.0.0.1/tcp/10${num}`,
-            `/ip4/127.0.0.1/tcp/20${num}/ws`
-          ],
-          API: `/ip4/127.0.0.1/tcp/31${num}`,
-          Gateway: `/ip4/127.0.0.1/tcp/32${num}`
-        }
-
-        config.Discovery.MDNS.Enabled = false
-
-        repo.config.set(config, cb)
-      })
-    },
-    (cb) => node.load(cb),
-    (cb) => {
-      const daemon = new HTTPAPI(node.repo.path())
-      nodes.push(daemon)
-      daemon.start(cb)
-    }
-  ], callback)
+  setTimeout(() => {
+    const daemon = new HTTPAPI(node.repo.path())
+    nodes.push(daemon)
+    daemon.start(callback)
+  }, 400)
 }
 
 gulp.task('libnode:start', (done) => {
@@ -66,7 +61,7 @@ gulp.task('libnode:start', (done) => {
 
 gulp.task('libnode:stop', (done) => {
   series(nodes.map((node) => (cb) => {
-    setTimeout(() => node.stop(cb), 200)
+    setTimeout(() => node.stop(cb), 100)
   }), done)
 })
 
diff --git a/src/cli/commands/init.js b/src/cli/commands/init.js
index c165b53e9f..20550602a4 100644
--- a/src/cli/commands/init.js
+++ b/src/cli/commands/init.js
@@ -17,11 +17,6 @@ module.exports = {
       default: '2048',
       describe: 'Number of bits to use in the generated RSA private key (defaults to 2048)'
     },
-    force: {
-      alias: 'f',
-      type: 'boolean',
-      describe: 'Overwrite existing config (if it exists)'
-    },
     emptyRepo: {
       alias: 'e',
       type: 'boolean',
@@ -39,16 +34,16 @@ module.exports = {
       stores: Store
     })
 
-    const ipfs = new IPFS({
+    const node = new IPFS({
       repo: repo,
-      EXPERIMENTAL: {}
+      init: false,
+      start: false
     })
 
-    ipfs.init({
+    node.init({
       bits: argv.bits,
-      force: argv.force,
       emptyRepo: argv.emptyRepo,
-      log
+      log: log
     }, (err) => {
       if (err) {
         console.error(err.toString())
diff --git a/src/cli/utils.js b/src/cli/utils.js
index b46731f78d..6c8f32e190 100644
--- a/src/cli/utils.js
+++ b/src/cli/utils.js
@@ -35,18 +35,20 @@ function getAPICtl () {
 }
 
 exports.getIPFS = (callback) => {
-  if (!isDaemonOn()) {
-    const ipfs = new IPFS({
-      repo: exports.getRepoPath(),
-      EXPERIMENTAL: {
-        pubsub: true
-      }
-    })
-    ipfs.load(() => callback(null, ipfs))
-    return
+  if (isDaemonOn()) {
+    return callback(null, getAPICtl())
   }
 
-  callback(null, getAPICtl())
+  const node = new IPFS({
+    repo: exports.getRepoPath(),
+    init: false,
+    start: false,
+    EXPERIMENTAL: {
+      pubsub: true
+    }
+  })
+
+  node.preStart(() => callback(null, node))
 }
 
 exports.getRepoPath = () => {
diff --git a/src/core/components/index.js b/src/core/components/index.js
index 28193af597..8eca1acb30 100644
--- a/src/core/components/index.js
+++ b/src/core/components/index.js
@@ -1,9 +1,9 @@
 'use strict'
 
-exports.goOnline = require('./go-online')
-exports.goOffline = require('./go-offline')
+exports.preStart = require('./pre-start')
+exports.start = require('./start')
+exports.stop = require('./stop')
 exports.isOnline = require('./is-online')
-exports.load = require('./load')
 exports.version = require('./version')
 exports.id = require('./id')
 exports.repo = require('./repo')
diff --git a/src/core/components/is-online.js b/src/core/components/is-online.js
index 5c07edb4e3..666aecf808 100644
--- a/src/core/components/is-online.js
+++ b/src/core/components/is-online.js
@@ -2,6 +2,6 @@
 
 module.exports = function isOnline (self) {
   return () => {
-    return self._bitswap && self._libp2pNode
+    return Boolean(self._bitswap && self._libp2pNode)
   }
 }
diff --git a/src/core/components/load.js b/src/core/components/pre-start.js
similarity index 76%
rename from src/core/components/load.js
rename to src/core/components/pre-start.js
index b2a7ccd239..f16ffeff0b 100644
--- a/src/core/components/load.js
+++ b/src/core/components/pre-start.js
@@ -7,21 +7,28 @@ const waterfall = require('async/waterfall')
 
 const utils = require('../utils')
 
-module.exports = function load (self) {
+/*
+ * Load stuff from Repo into memory
+ */
+module.exports = function preStart (self) {
   return (callback) => {
     waterfall([
       (cb) => utils.ifRepoExists(self._repo, cb),
       (cb) => self._repo.config.get(cb),
       (config, cb) => {
-        peerId.createFromPrivKey(config.Identity.PrivKey, (err, id) => {
+        const privKey = config.Identity.PrivKey
+
+        peerId.createFromPrivKey(privKey, (err, id) => {
           cb(err, config, id)
         })
       },
       (config, id, cb) => {
         self._peerInfo = new PeerInfo(id)
+
         config.Addresses.Swarm.forEach((addr) => {
           self._peerInfo.multiaddr.add(multiaddr(addr))
         })
+
         cb()
       }
     ], callback)
diff --git a/src/core/components/go-online.js b/src/core/components/start.js
similarity index 80%
rename from src/core/components/go-online.js
rename to src/core/components/start.js
index c6456d96c0..3209f2fb14 100644
--- a/src/core/components/go-online.js
+++ b/src/core/components/start.js
@@ -6,8 +6,10 @@ const FloodSub = require('libp2p-floodsub')
 
 module.exports = (self) => {
   return (callback) => {
+    callback = callback || function noop () {}
+
     series([
-      (cb) => self.load(cb),
+      (cb) => self.preStart(cb),
       (cb) => self.libp2p.start(cb)
     ], (err) => {
       if (err) {
@@ -20,11 +22,12 @@ module.exports = (self) => {
         self._peerInfoBook
       )
 
-      const pubsub = self._configOpts.EXPERIMENTAL.pubsub
+      const pubsub = self._options.EXPERIMENTAL.pubsub
 
       if (pubsub) {
         self._pubsub = new FloodSub(self._libp2pNode)
       }
+
       series([
         (cb) => {
           self._bitswap.start()
@@ -40,6 +43,10 @@ module.exports = (self) => {
           } else {
             cb()
           }
+        },
+        (cb) => {
+          self.emit('start')
+          cb()
         }
       ], callback)
     })
diff --git a/src/core/components/go-offline.js b/src/core/components/stop.js
similarity index 54%
rename from src/core/components/go-offline.js
rename to src/core/components/stop.js
index e68f450559..0a38350056 100644
--- a/src/core/components/go-offline.js
+++ b/src/core/components/stop.js
@@ -2,10 +2,12 @@
 
 module.exports = (self) => {
   return (callback) => {
+    callback = callback || function noop () {}
+
     self._blockService.goOffline()
     self._bitswap.stop()
 
-    if (self._configOpts.EXPERIMENTAL.pubsub) {
+    if (self._options.EXPERIMENTAL.pubsub) {
       self._pubsub.stop(next)
     } else {
       next()
@@ -15,7 +17,13 @@ module.exports = (self) => {
       if (err) {
         return callback(err)
       }
-      self.libp2p.stop(callback)
+      self.libp2p.stop((err) => {
+        if (err) {
+          return callback(err)
+        }
+        self.emit('stop')
+        callback()
+      })
     }
   }
 }
diff --git a/src/core/default-repo.js b/src/core/default-repo.js
index c826416668..a65098bf78 100644
--- a/src/core/default-repo.js
+++ b/src/core/default-repo.js
@@ -8,7 +8,5 @@ const path = require('path')
 module.exports = (dir) => {
   const repoPath = dir || path.join(os.homedir(), '.jsipfs')
 
-  return new IPFSRepo(repoPath, {
-    stores: Store
-  })
+  return new IPFSRepo(repoPath, { stores: Store })
 }
diff --git a/src/core/index.js b/src/core/index.js
index f3207a383f..7513e59fcb 100644
--- a/src/core/index.js
+++ b/src/core/index.js
@@ -9,39 +9,59 @@ const multihash = require('multihashes')
 const PeerBook = require('peer-book')
 const CID = require('cids')
 const debug = require('debug')
+const extend = require('deep-extend')
+const series = require('async/series')
+const EventEmitter = require('events')
 
 const defaultRepo = require('./default-repo')
 
 const components = require('./components')
 
-class IPFS {
-  constructor (configOpts) {
-    configOpts = configOpts || {}
-    let repoInstance
-    if (typeof configOpts.repo === 'string' || configOpts.repo === undefined) {
-      repoInstance = defaultRepo(configOpts.repo)
-    } else {
-      repoInstance = configOpts.repo
+class IPFS extends EventEmitter {
+  constructor (options) {
+    super()
+
+    this._options = {
+      init: true,
+      start: true,
+      EXPERIMENTAL: {}
     }
-    delete configOpts.repo
 
-    configOpts.EXPERIMENTAL = configOpts.EXPERIMENTAL || {}
+    extend(this._options, options)
 
-    // IPFS utils
-    this.types = {
-      Buffer,
-      PeerId,
-      PeerInfo,
-      multiaddr,
-      multihash,
-      CID
+    if (typeof options.init === 'boolean' &&
+        options.init === false) {
+      this._options.init = false
+    }
+
+    if (!(typeof options.start === 'boolean' &&
+          options.start === false)) {
+      this._options.start = true
     }
+
+    if (typeof options.repo === 'string' ||
+        options.repo === undefined) {
+      this._repo = defaultRepo(options.repo)
+    } else {
+      this._repo = options.repo
+    }
+
+    // IPFS utils
     this.log = debug('jsipfs')
     this.log.err = debug('jsipfs:err')
 
+    // IPFS types
+    this.types = {
+      Buffer: Buffer,
+      PeerId: PeerId,
+      PeerInfo: PeerInfo,
+      multiaddr: multiaddr,
+      multihash: multihash,
+      CID: CID
+    }
+
     // IPFS Core Internals
-    this._configOpts = configOpts
-    this._repo = repoInstance
+    // this._repo - assigned above
     this._peerInfoBook = new PeerBook()
     this._peerInfo = undefined
     this._libp2pNode = undefined
@@ -52,11 +72,11 @@ class IPFS {
 
     // IPFS Core exposed components
     //   - for booting up a node
-    this.goOnline = components.goOnline(this)
-    this.goOffline = components.goOffline(this)
-    this.isOnline = components.isOnline(this)
-    this.load = components.load(this)
     this.init = components.init(this)
+    this.preStart = components.preStart(this)
+    this.start = components.start(this)
+    this.stop = components.stop(this)
+    this.isOnline = components.isOnline(this)
     //   - interface-ipfs-core defined API
     this.version = components.version(this)
     this.id = components.id(this)
@@ -73,10 +93,48 @@ class IPFS {
     this.ping = components.ping(this)
     this.pubsub = components.pubsub(this)
 
-    if (configOpts.EXPERIMENTAL.pubsub) {
+    if (this._options.EXPERIMENTAL.pubsub) {
       this.log('EXPERIMENTAL pubsub is enabled')
     }
+
+    // Boot
+    series([
+      (cb) => {
+        this._options.init
+          ? this.init({ bits: this._options.init.bits || 2048 }, cb)
+          : cb()
+      },
+      (cb) => {
+        if (!(this._options.config &&
+              typeof this._options.config === 'object' &&
+              this._options.init)) {
+          return cb()
+        }
+
+        this._repo.config.get((err, config) => {
+          if (err) {
+            return cb(err)
+          }
+
+          extend(config, this._options.config)
+          this._repo.config.set(config, cb)
+        })
+      },
+      (cb) => {
+        this._options.start
+          ? this.start(cb)
+          : cb()
+      }
+    ], (err) => {
+      if (err) {
+        this.emit('error', err)
+      }
+    })
   }
 }
 
-module.exports = IPFS
+exports = module.exports = IPFS
+
+exports.createNode = (options) => {
+  return new IPFS(options)
+}
diff --git a/src/http-api/index.js b/src/http-api/index.js
index 21c6e1ed8b..f941c7e062 100644
--- a/src/http-api/index.js
+++ b/src/http-api/index.js
@@ -32,6 +32,8 @@ exports = module.exports = function HttpApi (repo) {
 
     this.ipfs = new IPFS({
       repo: repo,
+      init: false,
+      start: false,
       EXPERIMENTAL: {
         pubsub: true
       }
@@ -47,75 +49,71 @@ exports = module.exports = function HttpApi (repo) {
 
     console.log('Starting at %s', this.ipfs.repo.path())
 
-    this.ipfs.load(() => {
-      const apiPath = path.join(repoPath, 'api')
+    const apiPath = path.join(repoPath, 'api')
 
-      try {
-        fs.statSync(apiPath)
-        console.log('This repo is currently being used by another daemon')
-        process.exit(1)
-      } catch (err) {}
+    try {
+      fs.statSync(apiPath)
+      console.log('This repo is currently being used by another daemon')
+      process.exit(1)
+    } catch (err) {}
 
-      this.ipfs.config.get((err, config) => {
-        if (err) {
-          return callback(err)
-        }
+    this.ipfs._repo.config.get((err, config) => {
+      if (err) {
+        return callback(err)
+      }
 
-        // TODO: set up cors correctly, following config
-        this.server = new Hapi.Server({
-          connections: {
-            routes: {
-              cors: true
-            }
-          }
-        })
+      // CORS is enabled by default
+      this.server = new Hapi.Server({ connections: { routes: { cors: true } } })
 
-        this.server.app.ipfs = this.ipfs
-        const api = config.Addresses.API.split('/')
-        const gateway = config.Addresses.Gateway.split('/')
+      this.server.app.ipfs = this.ipfs
+      const api = config.Addresses.API.split('/')
+      const gateway = config.Addresses.Gateway.split('/')
 
-        // select which connection with server.select(<label>) to add routes
-        this.server.connection({
-          host: api[2],
-          port: api[4],
-          labels: 'API'
-        })
+      // select which connection with server.select(<label>) to add routes
+      this.server.connection({
+        host: api[2],
+        port: api[4],
+        labels: 'API'
+      })
 
-        this.server.connection({
-          host: gateway[2],
-          port: gateway[4],
-          labels: 'Gateway'
-        })
+      this.server.connection({
+        host: gateway[2],
+        port: gateway[4],
+        labels: 'Gateway'
+      })
+
+      // Nicer errors
+      errorHandler(this.server)
 
-        // Nicer errors
-        errorHandler(this.server)
+      // load routes
+      require('./routes')(this.server)
 
-        // load routes
-        require('./routes')(this.server)
+      // Set default headers
+      setHeader(this.server, 'Access-Control-Allow-Headers', 'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+      setHeader(this.server, 'Access-Control-Expose-Headers', 'X-Stream-Output, X-Chunked-Output, X-Content-Length')
 
-        // Set default headers
-        setHeader(this.server, 'Access-Control-Allow-Headers', 'X-Stream-Output, X-Chunked-Output, X-Content-Length')
-        setHeader(this.server, 'Access-Control-Expose-Headers', 'X-Stream-Output, X-Chunked-Output, X-Content-Length')
+      this.ipfs.start((err) => {
+        if (err) {
+          return callback(err)
+        }
 
-        this.ipfs.goOnline(() => {
-          this.server.start((err) => {
-            if (err) {
-              return callback(err)
-            }
-            const api = this.server.select('API')
-            const gateway = this.server.select('Gateway')
-            this.apiMultiaddr = multiaddr('/ip4/127.0.0.1/tcp/' + api.info.port)
-            api.info.ma = uriToMultiaddr(api.info.uri)
-            gateway.info.ma = uriToMultiaddr(gateway.info.uri)
+        this.server.start((err) => {
+          if (err) {
+            return callback(err)
+          }
+          const api = this.server.select('API')
+          const gateway = this.server.select('Gateway')
+          this.apiMultiaddr = multiaddr('/ip4/127.0.0.1/tcp/' + api.info.port)
+          api.info.ma = uriToMultiaddr(api.info.uri)
+          gateway.info.ma = uriToMultiaddr(gateway.info.uri)
 
-            console.log('API is listening on: %s', api.info.ma)
-            console.log('Gateway (readonly) is listening on: %s', gateway.info.ma)
+          console.log('API is listening on: %s', api.info.ma)
+          console.log('Gateway (readonly) is listening on: %s', gateway.info.ma)
 
-            // for the CLI to know the where abouts of the API
-            fs.writeFileSync(apiPath, api.info.ma)
+          // for the CLI to know the where abouts of the API
+          fs.writeFileSync(apiPath, api.info.ma)
 
-            callback()
-          })
+          callback()
         })
       })
     })
@@ -129,7 +127,7 @@ exports = module.exports = function HttpApi (repo) {
 
     parallel([
       (cb) => this.server.stop(cb),
-      (cb) => this.ipfs.goOffline(cb)
+      (cb) => this.ipfs.stop(cb)
     ], (err) => {
       if (err) {
         console.log('There were errors stopping')
diff --git a/test/core/bitswap.spec.js b/test/core/bitswap.spec.js
index 360f0071c2..8a4b58ed77 100644
--- a/test/core/bitswap.spec.js
+++ b/test/core/bitswap.spec.js
@@ -31,8 +31,11 @@ describe('bitswap', () => {
 
   beforeEach((done) => {
     const repo = createTempRepo()
+
     inProcNode = new IPFS({
       repo: repo,
+      init: false,
+      start: false,
       EXPERIMENTAL: {
         pubsub: true
       }
@@ -50,8 +53,7 @@ describe('bitswap', () => {
           cb()
         }
       },
-      (cb) => inProcNode.config.set('Discovery.MDNS.Enabled', false, cb),
-      (cb) => inProcNode.load(cb)
+      (cb) => inProcNode.config.set('Discovery.MDNS.Enabled', false, cb)
     ], done)
   })
 
@@ -121,11 +123,11 @@ describe('bitswap', () => {
 
     describe('fetches a remote block', () => {
       beforeEach((done) => {
-        inProcNode.goOnline(done)
+        inProcNode.start(done)
       })
 
       afterEach((done) => {
-        setTimeout(() => inProcNode.goOffline(done), 1500)
+        setTimeout(() => inProcNode.stop(done), 1500)
       })
 
       it('2 peers', (done) => {
@@ -209,11 +211,11 @@ describe('bitswap', () => {
 
     describe('fetches a remote file', () => {
       beforeEach((done) => {
-        inProcNode.goOnline(done)
+        inProcNode.start(done)
       })
 
       afterEach((done) => {
-        setTimeout(() => inProcNode.goOffline(done), 1500)
+        setTimeout(() => inProcNode.stop(done), 1500)
       })
 
       it('2 peers', (done) => {
@@ -252,11 +254,11 @@ describe('bitswap', () => {
       })
 
       it('returns an array of wanted blocks', (done) => {
-        inProcNode.goOnline((err) => {
+        inProcNode.start((err) => {
           expect(err).to.not.exist
           expect(inProcNode.bitswap.wantlist())
-            .to.be.eql([])
-          inProcNode.goOffline(done)
+            .to.eql([])
+          inProcNode.stop(done)
         })
       })
 
@@ -268,7 +270,7 @@ describe('bitswap', () => {
         })
 
         it('returns the stats', (done) => {
-          inProcNode.goOnline((err) => {
+          inProcNode.start((err) => {
             expect(err).to.not.exist
 
             let stats = inProcNode.bitswap.stat()
@@ -281,7 +283,7 @@ describe('bitswap', () => {
               'dupBlksReceived'
             ])
 
-            inProcNode.goOffline(done)
+            inProcNode.stop(done)
           })
         })
       })
diff --git a/test/core/bootstrap.spec.js b/test/core/bootstrap.spec.js
index c5c0bb5f2c..fa9107b2d8 100644
--- a/test/core/bootstrap.spec.js
+++ b/test/core/bootstrap.spec.js
@@ -3,7 +3,6 @@
 
 const expect = require('chai').expect
 const isNode = require('detect-node')
-const series = require('async/series')
 
 // This gets replaced by require('../utils/create-repo-browser.js')
 // in the browser
@@ -14,22 +13,28 @@ const IPFS = require('../../src/core')
 describe('bootstrap', () => {
   if (!isNode) { return }
 
-  let ipfs
+  let node
 
   before((done) => {
-    const repo = createTempRepo()
-    ipfs = new IPFS({
-      repo: repo,
+    node = new IPFS({
+      repo: createTempRepo(),
+      init: {
+        bits: 1024
+      },
       EXPERIMENTAL: {
         pubsub: true
       }
     })
-    series([
-      (cb) => ipfs.init({ bits: 1024 }, cb),
-      (cb) => ipfs.load(cb)
-    ], done)
+
+    node.on('error', (err) => {
+      expect(err).to.not.exist
+    })
+
+    node.on('start', done)
   })
 
+  after((done) => node.stop(done))
+
   const defaultList = [
     '/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
     '/ip4/104.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z',
@@ -56,7 +61,7 @@ describe('bootstrap', () => {
   ]
 
   it('get bootstrap list', (done) => {
-    ipfs.bootstrap.list((err, list) => {
+    node.bootstrap.list((err, list) => {
       expect(err).to.not.exist
       expect(list.Peers).to.deep.equal(defaultList)
       done()
@@ -64,10 +69,10 @@ describe('bootstrap', () => {
   })
 
   it('add a peer to the bootstrap list', (done) => {
-    ipfs.bootstrap.add('/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT', (err, res) => {
+    node.bootstrap.add('/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT', (err, res) => {
       expect(err).to.not.exist
       expect(res).to.be.eql({Peers: ['/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT']})
-      ipfs.bootstrap.list((err, list) => {
+      node.bootstrap.list((err, list) => {
         expect(err).to.not.exist
         expect(list.Peers).to.deep.equal(updatedList)
         done()
@@ -76,10 +81,10 @@ describe('bootstrap', () => {
   })
 
   it('remove a peer from the bootstrap list', (done) => {
-    ipfs.bootstrap.rm('/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT', (err, res) => {
+    node.bootstrap.rm('/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT', (err, res) => {
       expect(err).to.not.exist
       expect(res).to.be.eql({Peers: ['/ip4/111.111.111.111/tcp/1001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLUVIT']})
-      ipfs.bootstrap.list((err, list) => {
+      node.bootstrap.list((err, list) => {
         expect(err).to.not.exist
         expect(list.Peers).to.deep.equal(defaultList)
         done()
diff --git a/test/core/create-node.spec.js b/test/core/create-node.spec.js
new file mode 100644
index 0000000000..1801c29a17
--- /dev/null
+++ b/test/core/create-node.spec.js
@@ -0,0 +1,187 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const isNode = require('detect-node')
+const IPFS = require('../../src/core')
+
+// This gets replaced by require('../utils/create-repo-browser.js')
+// in the browser
+const createTempRepo = require('../utils/create-repo-node.js')
+
+describe('create node', () => {
+  it('custom repoPath', (done) => {
+    const node = new IPFS({
+      repo: '/tmp/ipfs-repo-' + Math.random()
+    })
+
+    node.on('start', (err) => {
+      expect(err).to.not.exist
+
+      node.config.get((err, config) => {
+        expect(err).to.not.exist
+
+        expect(config.Identity).to.exist
+        node.on('stop', done)
+        node.stop()
+      })
+    })
+  })
+
+  it('custom repo', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo()
+    })
+
+    node.on('start', (err) => {
+      expect(err).to.not.exist
+      node.config.get((err, config) => {
+        expect(err).to.not.exist
+
+        expect(config.Identity).to.exist
+        node.on('stop', done)
+        node.stop()
+      })
+    })
+  })
+
+  it('IPFS.createNode', (done) => {
+    const node = IPFS.createNode({
+      repo: createTempRepo()
+    })
+
+    node.on('start', (err) => {
+      expect(err).to.not.exist
+      node.config.get((err, config) => {
+        expect(err).to.not.exist
+
+        expect(config.Identity).to.exist
+        // note: key length doesn't map to buffer length
+        expect(config.Identity.PrivKey.length).is.below(2048)
+
+        node.on('stop', done)
+        node.stop()
+      })
+    })
+  })
+
+  it('init: { bits: 1024 }', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo(),
+      init: {
+        bits: 1024
+      }
+    })
+
+    node.on('start', (err) => {
+      expect(err).to.not.exist
+      node.config.get((err, config) => {
+        expect(err).to.not.exist
+        expect(config.Identity).to.exist
+        expect(config.Identity.PrivKey.length).is.below(1024)
+        node.on('stop', done)
+        node.stop()
+      })
+    })
+  })
+
+  it('init: false errors (start default: true)', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo(),
+      init: false
+    })
+    node.on('error', (err) => {
+      expect(err).to.exist
+      done()
+    })
+  })
+
+  it('init: false, start: false', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo(),
+      init: false,
+      start: false
+    })
+
+    let happened = false
+
+    function shouldNotHappen () {
+      happened = true
+    }
+
+    node.on('error', shouldNotHappen)
+    node.on('start', shouldNotHappen)
+    node.on('stop', shouldNotHappen)
+
+    setTimeout(() => {
+      expect(happened).to.be.false
+      done()
+    }, 250)
+  })
+
+  it('init: true, start: false', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo(),
+      init: true,
+      start: false
+    })
+
+    setTimeout(() => {
+      node.on('start', () => node.stop(done))
+      node.start()
+    }, 250)
+  })
+
+  it('init: true, start: false, use callback', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo(),
+      init: true,
+      start: false
+    })
+
+    setTimeout(() => {
+      node.start(() => node.stop(done))
+    }, 500)
+  })
+
+  it('overload config', (done) => {
+    if (!isNode) {
+      return done()
+    }
+    const node = new IPFS({
+      repo: createTempRepo(),
+      config: {
+        Addresses: {
+          Swarm: ['/ip4/127.0.0.1/tcp/9977']
+        }
+      }
+    })
+
+    node.on('start', (err) => {
+      expect(err).to.not.exist
+      node.config.get((err, config) => {
+        expect(err).to.not.exist
+
+        expect(config.Addresses.Swarm).to.eql(
+          ['/ip4/127.0.0.1/tcp/9977']
+        )
+        node.stop(done)
+      })
+    })
+  })
+
+  it('start and stop, start and stop', (done) => {
+    const node = new IPFS({
+      repo: createTempRepo()
+    })
+
+    node.once('start', () => {
+      node.stop(() => {
+        node.start(() => {
+          node.stop(done)
+        })
+      })
+    })
+  })
+})
diff --git a/test/core/init.spec.js b/test/core/init.spec.js
index f2f1cec902..3024fe7a95 100644
--- a/test/core/init.spec.js
+++ b/test/core/init.spec.js
@@ -23,11 +23,11 @@ describe('init', () => {
 
   beforeEach(() => {
     repo = createTempRepo()
+
     ipfs = new IPFS({
       repo: repo,
-      EXPERIMENTAL: {
-        pubsub: true
-      }
+      init: false,
+      start: false
     })
   })
 
@@ -91,12 +91,12 @@ describe('init', () => {
 
   it('data types', () => {
     expect(ipfs.types).to.be.deep.equal({
-      Buffer,
-      PeerId,
-      PeerInfo,
-      multiaddr,
-      multihash,
-      CID
+      Buffer: Buffer,
+      PeerId: PeerId,
+      PeerInfo: PeerInfo,
+      multiaddr: multiaddr,
+      multihash: multihash,
+      CID: CID
     })
   })
 })
diff --git a/test/utils/ipfs-factory-daemon/index.js b/test/utils/ipfs-factory-daemon/index.js
index b21b4ed2ca..a3929a6392 100644
--- a/test/utils/ipfs-factory-daemon/index.js
+++ b/test/utils/ipfs-factory-daemon/index.js
@@ -25,40 +25,45 @@ class Factory {
       config = undefined
     }
 
-    repoPath = repoPath || os.tmpdir() +
-      '/ipfs-' + Math.random().toString().substring(2, 8)
+    repoPath = repoPath ||
+      os.tmpdir() + '/ipfs-' + Math.random().toString().substring(2, 8)
 
-    let node
     let daemon
     let ctl
 
     series([
       (cb) => {
-        if (config) { return cb() }
+        // prepare config for node
+        if (config) {
+          return cb()
+        }
 
         config = JSON.parse(JSON.stringify(defaultConfig))
 
         PeerId.create({ bits: 1024 }, (err, id) => {
-          if (err) { return cb(err) }
+          if (err) {
+            return cb(err)
+          }
 
-          const pId = id.toJSON()
-          config.Identity.PeerID = pId.id
-          config.Identity.PrivKey = pId.privKey
+          const peerId = id.toJSON()
+          config.Identity.PeerID = peerId.id
+          config.Identity.PrivKey = peerId.privKey
           cb()
         })
       },
       (cb) => {
         // create the node
-        node = new IPFS({
+        IPFS.createNode({
           repo: repoPath,
+          start: false,
+          config: config,
           EXPERIMENTAL: {
             pubsub: true
           }
         })
 
-        node.init({ emptyRepo: true }, cb)
+        setTimeout(cb, 400)
       },
-      (cb) => node._repo.config.set(config, cb),
       (cb) => {
         // create the daemon
         daemon = new HTTPAPI(repoPath)
@@ -79,7 +84,9 @@ class Factory {
   dismantle (callback) {
     const tasks = this.daemonsSpawned.map((daemon) => (cb) => {
       daemon.stop((err) => {
-        if (err) { return cb(err) }
+        if (err) {
+          return cb(err)
+        }
         clean(daemon.repoPath)
         cb()
       })
diff --git a/test/utils/ipfs-factory-instance/index.js b/test/utils/ipfs-factory-instance/index.js
index 2c81ae6489..04b117a4cf 100644
--- a/test/utils/ipfs-factory-instance/index.js
+++ b/test/utils/ipfs-factory-instance/index.js
@@ -33,57 +33,33 @@ function Factory () {
                                  .substring(2, 8)
     }
 
-    createConfig(config, (err, conf) => {
+    createConfig(config, (err, config) => {
       if (err) {
         return callback(err)
       }
 
-      config = conf
-
-      const repo = createTempRepo(repoPath)
-
       // create the IPFS node
-      const ipfs = new IPFS({
+      const repo = createTempRepo(repoPath)
+      const node = new IPFS({
         repo: repo,
+        config: config,
         EXPERIMENTAL: {
           pubsub: true
         }
       })
 
-      ipfs.init({ emptyRepo: true, bits: 1024 }, (err) => {
-        if (err) {
-          return callback(err)
-        }
-        repo.config.set(config, launchNode)
+      node.on('start', () => {
+        nodes.push({ repo: repo, ipfs: node })
+        callback(null, node)
       })
-
-      function launchNode () {
-        ipfs.load((err) => {
-          if (err) {
-            return callback(err)
-          }
-
-          ipfs.goOnline((err) => {
-            if (err) {
-              return callback(err)
-            }
-
-            nodes.push({
-              repo: repo,
-              ipfs: ipfs
-            })
-
-            callback(null, ipfs)
-          })
-        })
-      }
     })
 
     function createConfig (config, cb) {
       if (config) {
         return cb(null, config)
       }
-      const conf = JSON.parse(JSON.stringify(defaultConfig))
+
+      config = JSON.parse(JSON.stringify(defaultConfig))
 
       PeerId.create({ bits: 1024 }, (err, id) => {
         if (err) {
@@ -91,28 +67,17 @@ function Factory () {
         }
 
         const pId = id.toJSON()
-        conf.Identity.PeerID = pId.id
-        conf.Identity.PrivKey = pId.privKey
-        cb(null, conf)
+        config.Identity.PeerID = pId.id
+        config.Identity.PrivKey = pId.privKey
+        cb(null, config)
       })
     }
   }
 
   this.dismantle = function (callback) {
-    series(nodes.map((node) => {
-      return node.ipfs.goOffline
-    }), clean)
-
-    function clean (err) {
-      if (err) {
-        return callback(err)
-      }
-      series(
-        nodes.map((node) => {
-          return node.repo.teardown
-        }),
-        callback
-      )
-    }
+    series([
+      (cb) => series(nodes.map((el) => el.ipfs.stop), cb),
+      (cb) => series(nodes.map((el) => el.repo.teardown), cb)
+    ], callback)
   }
 }