diff --git a/d3py/__init__.py b/d3py/__init__.py
index 5e9ed68..51b38e9 100644
--- a/d3py/__init__.py
+++ b/d3py/__init__.py
@@ -1,3 +1,4 @@
+from displayable import SimpleServer, displayable
 from pandas_figure import *
 from networkx_figure import *
 from geoms import *
diff --git a/d3py/deployable.py b/d3py/deployable.py
new file mode 100644
index 0000000..019bee5
--- /dev/null
+++ b/d3py/deployable.py
@@ -0,0 +1,68 @@
+from abc import ABCMeta
+from exceptions import NotImplementedError
+
+import logging
+import os
+
+class deployable():
+    """
+    Given a d3py.figure, deployable stores it persistently. Concrete classes
+    may simply save the files to the file system or be used to deploy them 
+    in the cloud. 
+    """
+    
+    __metaclass__ = ABCMeta
+
+    def save(self, fig):
+        raise NotImplementedError
+    
+    @staticmethod
+    def default_deployable():
+        return FileSystem(dest_dir=os.path.join(os.getcwd(), 'deploy'))
+
+class FileSystem(deployable):
+    """
+    Concrete class which simply saves the files to the file system
+    """
+    def __init__(self, dest_dir=None, logging=False):
+        self._fig = None
+        self._dest_dir = dest_dir
+
+    @property
+    def fig(self):
+        return self._fig
+
+    @fig.setter
+    def fig(self, fig):
+        self._fig = fig
+        
+    @property
+    def dest_dir(self):
+        return self._dest_dir
+        
+    @dest_dir.setter
+    def dest_dir(self, new_dir):
+        self._dest_dir = new_dir
+
+    def save(self, ephermeral_dir=None):
+        """
+        Save the figure to dest_dir.  If the user supplies a directory,
+        via the ephermeral_dir argument, use it for this call. 
+        """
+        if ephermeral_dir is not None:
+            self._dest_dir = ephermeral_dir
+        if self._dest_dir is None:
+            raise Exception("Destination directory not defined")
+        static_dir = os.path.join(self._dest_dir, "static")
+        if not os.path.exists(static_dir):
+            os.makedirs(static_dir)
+        # NB: while this method makes sure we can write the static directory to the file system, figure controls the structure of the subdirectory. 
+        os.chdir(self._dest_dir)
+        for k_filename in self._fig.filemap:
+            f = os.path.join(self._dest_dir, k_filename)
+            with open(f, 'w',0644) as fd_out:
+                fd_in = self._fig.filemap[k_filename]["fd"]
+                fd_in.seek(0)
+                # import pdb; pdb.set_trace()
+                for line in fd_in.readlines():
+                    fd_out.write(line)
diff --git a/d3py/displayable.py b/d3py/displayable.py
new file mode 100644
index 0000000..7f5b316
--- /dev/null
+++ b/d3py/displayable.py
@@ -0,0 +1,157 @@
+from abc import ABCMeta
+from exceptions import NotImplementedError
+
+import logging
+
+# in support of SimpleServer 
+import threading
+import webbrowser
+from HTTPHandler import CustomHTTPRequestHandler, ThreadedHTTPServer
+
+# requires IPython 0.11.0 or higher
+import IPython.core.display
+
+class displayable():
+    """
+    Given a d3py.figure, displayables present the graph to the user. 
+    The first displayable is based on python's SimpleHTTPServer class.
+    
+    These classes should know nothing of html, css or javascript which
+    live in the figure class. 
+    """
+    __metaclass__ = ABCMeta
+    
+    def show(self, fig):
+        raise NotImplementedError
+        
+    @staticmethod
+    def default_displayable():
+        return SimpleServer()
+
+class SimpleServer(displayable):
+    """
+    Use Python's SimpleHTTPServer class to present this resulting d3 output
+    to the user. 
+    """
+    def __init__(self, host="localhost", port=8000, 
+        interactive=False, logging=False):
+
+        self._fig = None
+        self._host = host
+        self._port = port
+        self._server_thread = None
+        self._httpd = None
+        # interactive is True by default as this is designed to be a command line tool
+        # we do not want to block interaction after plotting.
+        self._interactive = interactive
+
+    @property
+    def fig(self):
+        return self._fig
+
+    @fig.setter
+    def fig(self, fig):
+        self._fig = fig
+
+    @property
+    def host(self):
+        return self._host 
+    
+    @property
+    def port(self):
+        return self._port
+
+    def ion(self):
+        """
+        Turns interactive mode on ala pylab
+        """
+        self._interactive = True
+    
+    def ioff(self):
+        """
+        Turns interactive mode off
+        """
+        self._interactive = False
+
+    def show(self, interactive=None):
+        if interactive is not None:
+            blocking = not interactive
+        else:
+            blocking = not self._interactive
+
+        if blocking:
+            self._serve(blocking=True)
+        else:
+            # if not blocking, we serve the 
+            self._serve(blocking=False)
+            # fire up a browser
+            webbrowser.open_new_tab("http://%s:%s/%s.html"%(self.host,self.port, self.name))
+
+    def _serve(self, blocking=True):
+        """
+        start up a server to serve the files for this vis.
+        """
+        msgparams = (self.host, self.port, self._fig.name)
+        url = "http://%s:%s/%s.html"%msgparams
+        if self._server_thread is None or self._server_thread.active_count() == 0:
+            Handler = CustomHTTPRequestHandler
+            Handler.filemap = self._fig.filemap
+            Handler.logging = self._fig.logging
+            try:
+                self._httpd = ThreadedHTTPServer(("", self.port), Handler)
+            except Exception, e:
+                print "Exception %s"%e
+                return False
+            if blocking:
+                logging.info('serving forever on port: %s'%msgparams[1])
+                msg = "You can find your chart at " + url
+                print msg
+                print "Ctrl-C to stop serving the chart and quit!"
+                self._server_thread = None
+                self._httpd.serve_forever()
+            else:
+                logging.info('serving asynchronously on port %s'%msgparams[1])
+                self._server_thread = threading.Thread(
+                    target=self._httpd.serve_forever
+                )
+                self._server_thread.daemon = True
+                self._server_thread.start()
+                msg = "You can find your chart at " + url
+                print msg
+
+
+    def __enter__(self):
+        self._interactive = False
+        return self
+
+    def __exit__(self, ex_type, ex_value, ex_tb):
+        if ex_tb is not None:
+            if ex_value is None:
+                print "Cleanup after exception: %s"%(ex_type)
+            else:
+                print "Cleanup after exception: %s: %s"%(ex_type, ex_value)
+        self._cleanup()
+
+    def __del__(self):
+        self._cleanup()
+
+    def _cleanup(self):
+        try:
+            if self._httpd is not None:
+                print "Shutting down httpd"
+                self._httpd.shutdown()
+                self._httpd.server_close()
+        except Exception, e:
+            print "Error in clean-up: %s"%e
+
+class IPython(displayable):
+    """
+    IPython integration 
+    """
+    def __init__(self):
+        pass
+        
+    def show(self, fig):
+        html = "<iframe src=http://%s:%s/%s.html width=%s height=%s>" % (
+            self.host, self.port, self.name, fig.width, fig.height)
+        IPython.core.display.HTML(html)
diff --git a/d3py/figure.py b/d3py/figure.py
index d816448..658b07e 100644
--- a/d3py/figure.py
+++ b/d3py/figure.py
@@ -1,38 +1,36 @@
 import logging
-import webbrowser
-from HTTPHandler import CustomHTTPRequestHandler, ThreadedHTTPServer
-import IPython.core.display
-import threading
-from cStringIO import StringIO
-import time
+
 import json
 import os
+from StringIO import StringIO
+import time
+
+import displayable
+import deployable
+
+from jinja2 import Template # well-known templating module
 
 from css import CSS
 import javascript as JS
 
 class Figure(object):
-    def __init__(self, name, width, height, interactive, font, logging,  template, host, port, **kwargs):
+    """
+    Maintains in internal representation of d3 geometries. This implies
+    an understanding of css,html and javascript. 
+    """
+    def __init__(self, name, width, height, font, 
+        logging, template, server, deploy, **kwargs):
 
         # store data
         self.name = '_'.join(name.split())
         d3py_path = os.path.abspath(os.path.dirname(__file__))
         self.filemap = {
-            "static/d3.js":{
-                "fd":open(d3py_path+"/d3.js","r"), 
+            os.path.join("static", "d3.js"):{
+                "fd":open(os.path.join(d3py_path,"d3.js"),"r"), 
                 "timestamp":time.time()
             },
         }
 
-        # Networking stuff
-        self.host = host
-        self.port = port
-        self._server_thread = None
-        self.httpd = None
-
-        # interactive is True by default as this is designed to be a command line tool
-        # we do not want to block interaction after plotting.
-        self.interactive = interactive
         self.logging = logging
 
         # initialise strings
@@ -48,8 +46,9 @@ def __init__(self, name, width, height, interactive, font, logging,  template, h
         
         # we use bostock's scheme http://bl.ocks.org/1624660
         self.css = CSS()
-        self.html = ""
-        self.template = template or "".join(open(d3py_path+'/d3py_template.html').readlines())
+
+        self.html = template or "".join(open(
+            os.path.join(d3py_path, 'd3py_template.html')).readlines())
         self.js_geoms = JS.JavaScript()
         self.css_geoms = CSS()
         self.geoms = []
@@ -62,12 +61,69 @@ def __init__(self, name, width, height, interactive, font, logging,  template, h
         }
         kwargs = dict([(k[0].replace('_','-'), k[1]) for k in kwargs.items()])
         self.args.update(kwargs)
+    
+        self._server = server 
+        self._deploy = deploy
+
+
+    def __enter__(self):
+        """
+        It is important that the Figure support the python's with statement.
+        """
+        if self._server is None: 
+            self._server = displayable.displayable.default_displayable()
+        self._server.fig = self
+        if hasattr(self._server,'__enter__'):
+            self._server.__enter__() 
+
+        if self._deploy is None:
+            self._deploy = deployable.deployable.default_deployable()
+        self._deploy.fig = self
+        if hasattr(self._deploy,'__enter__'):
+            self._deploy.__enter__()
+
+        # assertion: All variables used by the html template are 
+        #  known. Write the html based on the template. 
+        self._save_html(self._server.host, self._server.port)
+        return self
+    
+
+    def __exit__(self, ex_type, ex_value, ex_tb):
+        """
+        required to support with statement.
+        """
+        if hasattr(self._server, '__exit__'):
+            self._server.__exit__(ex_type, ex_value, ex_tb)
+        if hasattr(self._deploy, '__exit__'):
+            self._deploy.__exit__(ex_type, ex_value, ex_tb)
+        return False 
+
+    def ion(self):
+        """
+        Turns interactive mode on ala pylab
+        """
+        self._server.ion()
+
+    def ioff(self):
+        """
+        Turns interactive mode off
+        """
+        self._server.ioff()
+
+    def show(self):
+        self.update()
+        self.save()
+        self._server.show()
+
+    def deploy(self, ephermeral_dir=None):
+        self.update()
+        self.save()
+        self._deploy.save(ephermeral_dir)
 
     def _build(self):
         logging.debug('building chart')
         self._build_js()
         self._build_css()
-        self._build_html()
         self._build_geoms()
 
     def update(self):
@@ -76,39 +132,14 @@ def update(self):
         self.save()
 
     def save(self):
+        """
+        Saving the chart. _save_html() is not called here. It relies
+        on an html template. Since all values are available during construction, __init__() calls _save_hmtl() once. 
+        """
         logging.debug('saving chart')
         self._save_data()
         self._save_css()
         self._save_js()
-        self._save_html()
-
-    def _clanup(self):
-        raise NotImplementedError
-
-
-    def __enter__(self):
-        self.interactive = False
-        return self
-
-    def __exit__(self, ex_type, ex_value, ex_tb):
-        if ex_tb is not None:
-            print "Cleanup after exception: %s: %s"%(ex_type, ex_value)
-        self._cleanup()
-
-    def __del__(self):
-        self._cleanup()
-
-    def ion(self):
-        """
-        Turns interactive mode on ala pylab
-        """
-        self.interactive = True
-    
-    def ioff(self):
-        """
-        Turns interactive mode off
-        """
-        self.interactive = False
 
     def _set_data(self):
         self.update()
@@ -123,13 +154,6 @@ def _build_css(self):
         chart.update(self.args)
         self.css["#chart"] = chart
 
-    def _build_html(self):
-        # we start the html using a template - it's pretty simple
-        self.html = self.template
-        self.html = self.html.replace("{{ name }}", self.name)
-        self.html = self.html.replace("{{ font }}", self.font)
-        self._save_html()
-
     def _build_geoms(self):
         self.js_geoms = JS.JavaScript()
         self.css_geoms = CSS()
@@ -194,76 +218,15 @@ def _save_js(self):
         self.filemap[filename] = {"fd":StringIO(js),
                 "timestamp":time.time()}
 
-    def _save_html(self):
-        # update the html with the correct port number
-        self.html = self.html.replace("{{ port }}", str(self.port))
-        self.html = self.html.replace("{{ host }}", str(self.host))
-        # write html
-        filename = "%s.html"%self.name
-        self.filemap[filename] = {"fd":StringIO(self.html),
-                "timestamp":time.time()}
-
-    def show(self, interactive=None):
-        self.update()
-        self.save()
-        if interactive is not None:
-            blocking = not interactive
-        else:
-            blocking = not self.interactive
-
-        if blocking:
-            self._serve(blocking=True)
-        else:
-            # if not blocking, we serve the 
-            self._serve(blocking=False)
-            # fire up a browser
-            webbrowser.open_new_tab("http://%s:%s/%s.html"%(self.host,self.port, self.name))
-
-    def display(self, width=700, height=400):
-        html = "<iframe src=http://%s:%s/%s.html width=%s height=%s>" %(self.host, self.port, self.name, width, height)
-        IPython.core.display.HTML(html)
-
-    def _serve(self, blocking=True):
+    def _save_html(self, a_host, a_port):
         """
-        start up a server to serve the files for this vis.
+        Bind a var in the html template code with that value provided. 
+        Implies all related variables defined. 
         """
-        msgparams = (self.host, self.port, self.name)
-        url = "http://%s:%s/%s.html"%msgparams
-        if self._server_thread is None or self._server_thread.active_count() == 0:
-            Handler = CustomHTTPRequestHandler
-            Handler.filemap = self.filemap
-            Handler.logging = self.logging
-            try:
-                self.httpd = ThreadedHTTPServer(("", self.port), Handler)
-            except Exception, e:
-                print "Exception %s"%e
-                return False
-            if blocking:
-                logging.info('serving forever on port: %s'%msgparams[1])
-                msg = "You can find your chart at " + url
-                print msg
-                print "Ctrl-C to stop serving the chart and quit!"
-                self._server_thread = None
-                self.httpd.serve_forever()
-            else:
-                logging.info('serving asynchronously on port %s'%msgparams[1])
-                self._server_thread = threading.Thread(
-                    target=self.httpd.serve_forever
-                )
-                self._server_thread.daemon = True
-                self._server_thread.start()
-                msg = "You can find your chart at " + url
-                print msg
-
-
-    def _cleanup(self):
-        try:
-            if self.httpd is not None:
-                print "Shutting down httpd"
-                self.httpd.shutdown()
-                self.httpd.server_close()
-        except Exception, e:
-            print "Error in clean-up: %s"%e
-
-
+        self.html_filename = "%s.html"%self.name
+        template = Template(self.html)
+        self.filemap[self.html_filename] = {
+            "fd":StringIO(template.render(name=self.name, host=a_host, port=a_port)),
+            "timestamp":time.time()
+        }
 
diff --git a/d3py/networkx_figure.py b/d3py/networkx_figure.py
index 1b4da91..bd911db 100644
--- a/d3py/networkx_figure.py
+++ b/d3py/networkx_figure.py
@@ -8,7 +8,7 @@
 class NetworkXFigure(Figure):
     def __init__(self, graph, name="figure", width=400, height=100, 
         interactive=True, font="Asap", logging=False,  template=None,
-        port=8000, **kwargs):
+        server=None, deploy=None, **kwargs):
         """
         data : networkx gprah
             networkx graph used for the plot.
@@ -35,8 +35,8 @@ def __init__(self, graph, name="figure", width=400, height=100,
         """
         super(NetworkXFigure, self).__init__(
             name=name, width=width, height=height, 
-            interactive=interactive, font=font, logging=logging,  template=template,
-            port=port, **kwargs
+            font=font, logging=logging,  template=template, 
+            server=server, deploy=deploy, **kwargs
         )
         # store data
         self.G = graph
diff --git a/d3py/pandas_figure.py b/d3py/pandas_figure.py
index 048a1ae..0eb980a 100644
--- a/d3py/pandas_figure.py
+++ b/d3py/pandas_figure.py
@@ -7,8 +7,8 @@
 
 class PandasFigure(Figure):
     def __init__(self, data, name="figure", width=800, height=400, 
-        interactive=True, font="Asap", logging=False,  template=None,
-        host="localhost", port=8000, **kwargs):
+        font="Asap", logging=False,  template=None, 
+        server=None, deploy=None, **kwargs):
         """
         data : dataFrame
             pandas dataFrame used for the plot. This dataFrame is column centric
@@ -20,9 +20,6 @@ def __init__(self, data, name="figure", width=800, height=400,
             width of the figure in pixels (default is 1024)
         height : int 
             height of the figure in pixels (default is 768)
-        interactive : boolean
-            set this to false if you are drawing the graph using a script and
-            not in the command line (default is True)
         font : string
             name of the font you'd like to use. See     
             http://www.google.com/webfonts for options (default is Asap)
@@ -33,8 +30,8 @@ def __init__(self, data, name="figure", width=800, height=400,
         """
         super(PandasFigure, self).__init__(
             name=name, width=width, height=height, 
-            interactive=interactive, font=font, logging=logging,  template=template,
-            host=host, port=port, **kwargs
+            font=font, logging=logging,  template=template, 
+            server=server,deploy=None, **kwargs
         )
         # store data
         self.data = data
diff --git a/examples/d3py_deploy.py b/examples/d3py_deploy.py
new file mode 100644
index 0000000..e8267b0
--- /dev/null
+++ b/examples/d3py_deploy.py
@@ -0,0 +1,33 @@
+import pandas
+import d3py
+from d3py.deployable import FileSystem
+
+import logging
+
+"""
+This example is based on d3py_bar.py but the goal is to highlight 
+how to deploy the figure. For the initial release, deploy simple allows
+one save the static files to the file system. One could imagine implemented
+other versions to deploy to the cloud. 
+"""
+
+df = pandas.DataFrame(
+    {
+        "count" : [1,4,7,3,2,9],
+        "apple_type": ["a", "b", "c", "d", "e", "f"],
+    }
+)
+
+# by default the deploy method will save the static files to the file system.
+with d3py.PandasFigure(df) as p:
+    p += d3py.Bar(x = "apple_type", y = "count", fill = "MediumAquamarine")
+    p += d3py.xAxis(x = "apple_type")
+    # default = look for deploy directory in cwd.
+    p.deploy() 
+    # For a given call you can overide the default by providing an argument
+    p.deploy(ephermeral_dir='/tmp/d3py') 
+
+
+# if you want to change the default directory, set the dest_dir argument
+# in the FileSystem constructor.  
+p2 = d3py.PandasFigure(df, deploy=FileSystem(dest_dir="/tmp"))
diff --git a/examples/d3py_server.py b/examples/d3py_server.py
new file mode 100644
index 0000000..9f78d5f
--- /dev/null
+++ b/examples/d3py_server.py
@@ -0,0 +1,26 @@
+import pandas
+import d3py
+from d3py.displayable import SimpleServer
+
+import logging
+
+"""
+This example is based on d3py_bar.py but the goal is to highlight 
+how to configure a server for your figure. For the initial release, 
+we simple support Python's SimpleHTTPServer. Got you sights on a different
+server? Look at the displayable module. 
+"""
+
+df = pandas.DataFrame(
+    {
+        "count" : [1,4,7,3,2,9],
+        "apple_type": ["a", "b", "c", "d", "e", "f"],
+    }
+)
+
+# by default point your browser to port 8000 at localhost
+# This example changes the port. 
+with d3py.PandasFigure(df,server=SimpleServer(port=7878)) as p:
+    p += d3py.Bar(x = "apple_type", y = "count", fill = "MediumAquamarine")
+    p += d3py.xAxis(x = "apple_type")    
+    p.show()