diff --git a/_data/existing_instrumentations.yml b/_data/existing_instrumentations.yml
index 12ce2a7..6d76da3 100644
--- a/_data/existing_instrumentations.yml
+++ b/_data/existing_instrumentations.yml
@@ -1,9 +1,21 @@
+- language: JavaScript
+  library: >-
+    [zipkin-js](https://github.com/openzipkin/zipkin-js)
+  framework: >-
+    [cujoJS](http://cujojs.com), [express](http://expressjs.com/)
+  propagation: Http (B3)
+  transports: >-
+    [Kafka \\| Scribe](https://github.com/openzipkin/zipkin-js#transports)
+  sampling: >-
+    Yes
+  notes: >-
+    Uses continuation-local-storage under to hood, so you don't have to pass around an explicit context
+
 - language: Python
   library: >-
     [pyramid_zipkin](https://github.com/Yelp/pyramid_zipkin)
   framework: >-
     [Pyramid](http://docs.pylonsproject.org/projects/pyramid/en/latest/)
-    Http (B3)
   propagation: Http (B3)
   transports: >-
     [Kafka \\| Scribe](http://pyramid-zipkin.readthedocs.org/en/latest/configuring_zipkin.html#zipkin-transport-handler)
@@ -15,7 +27,7 @@
   library: >-
     [brave](https://github.com/openzipkin/brave)
   framework: Jersey, RestEASY, JAXRS2, Apache HttpClient, Mysql
-  propagation: Http (B3)
+  propagation: Http (B3), gRPC (B3)
   transports: Http, Kafka, Scribe
   sampling: "Yes"
   notes: Java 6 or higher
@@ -65,6 +77,14 @@
   transports: Kafka
   sampling: "Yes"
 
+- language: Go
+  library: >-
+    [Go kit](https://github.com/go-kit/kit)
+  framework: Go kit
+  propagation: Http (B3), gRPC (B3)
+  transports: Kafka, Scribe
+  sampling: "Yes"
+
 - language: Scala
   library: >-
     [akka-tracing](https://github.com/levkhomich/akka-tracing)
@@ -74,3 +94,13 @@
   transports: Scribe
   sampling: "Yes"
   notes: Java 6+, Scala 2.10+, activator templates for [Akka](https://github.com/levkhomich/activator-akka-tracing) and [Play](https://github.com/levkhomich/activator-play-tracing)
+
+- language: Java
+  library: >-
+    [Dropwizard Zipkin](https://github.com/smoketurner/dropwizard-zipkin)
+  framework: >-
+    [Dropwizard](http://www.dropwizard.io)
+  propagation: Http (B3), Thrift
+  transports: Http, Scribe
+  sampling: "Yes"
+  notes: Java 7 or higher
diff --git a/google869265c574186afd.html b/google869265c574186afd.html
new file mode 100644
index 0000000..fe8df2f
--- /dev/null
+++ b/google869265c574186afd.html
@@ -0,0 +1 @@
+google-site-verification: google869265c574186afd.html
\ No newline at end of file
diff --git a/graphs/architecture/build.sh b/graphs/architecture/build.sh
new file mode 100755
index 0000000..4596610
--- /dev/null
+++ b/graphs/architecture/build.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+dot source.dot -Tpng -o graph.png
diff --git a/graphs/architecture/graph.png b/graphs/architecture/graph.png
new file mode 100644
index 0000000..1d80b0d
--- /dev/null
+++ b/graphs/architecture/graph.png
Binary files differ
diff --git a/graphs/architecture/source.dot b/graphs/architecture/source.dot
new file mode 100644
index 0000000..dd1d162
--- /dev/null
+++ b/graphs/architecture/source.dot
@@ -0,0 +1,42 @@
+digraph Architecture {
+  node[fontsize=12, height=0.35, fontname=Helvetica, shape=rect];
+  fontname=Helvetica;
+
+  subgraph cluster_your_app {
+    color=white;
+    node[fillcolor="#DDDDFF", style=filled];
+
+    client[label="Instrumented client\n(Reporter)"];
+    uninstrumented_server[label="Non-instrumented server"];
+    instrumented_server[label="Instrumented server\n(Reporter)"];
+
+    client -> instrumented_server;
+    client -> uninstrumented_server;
+  }
+
+  transport [label=Transport];
+  
+  subgraph cluster_zipkin {
+    label=Zipkin;
+    style=dashed;
+    node[fillcolor="#C3FF68", style=filled];
+
+    collector[label=Collector];
+    storage[label=Storage];
+    api[label=API];
+    ui[label=UI];
+
+    collector -> storage;
+    
+	api -> storage [dir=back];
+	ui -> api [dir=back];
+  }
+
+  database[label=Database];
+  storage -> database [style=dotted];
+
+  instrumented_server -> transport [color="#7ED0D6"];
+  client -> transport [color="#7ED0D6"];
+  transport -> collector;
+
+}
diff --git a/pages/instrumenting.md b/pages/instrumenting.md
index 187edfd..138a346 100644
--- a/pages/instrumenting.md
+++ b/pages/instrumenting.md
@@ -11,10 +11,12 @@
 
 Overview
 =======
+
 To instrument a library, you'll need to understand and create the following elements:
+
 1. Core data structures - the information that is collected and sent to Zipkin
 1. Trace identifiers - what tags for the information are needed so it can be reassembled in a logical order by Zipkin
-  * Generating identifiers - how to generate these Ids and which ids should be inherited
+  * Generating identifiers - how to generate these IDs and which IDs should be inherited
   * Communicating trace information - additional information that is sent to Zipkin along with the traces and their IDs.
 
 
@@ -37,7 +39,7 @@
   processing it. The difference between this and `cs` will be combination of
   network latency and clock jitter.
 * **ss** - Server Send: The server has completed processing and has sent the
-  request back to the client. The difference between this and `ss` will be the
+  request back to the client. The difference between this and `sr` will be the
   amount of time it took the server to process the request.
 * **cr** - Client Receiver: The client has received the response from the server.
   This sets the end of the span. The RPC is considered complete when this
