diff --git a/tools/playground/compilerd/main.go b/tools/playground/compilerd/main.go
index d2bcf02..aba5af6 100644
--- a/tools/playground/compilerd/main.go
+++ b/tools/playground/compilerd/main.go
@@ -2,9 +2,11 @@
 
 import (
 	"bytes"
+	"crypto/sha1"
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
 	"math/rand"
 	"net/http"
 	"os"
@@ -12,6 +14,8 @@
 	"os/signal"
 	"syscall"
 	"time"
+
+	"github.com/golang/groupcache/lru"
 )
 
 type Event struct {
@@ -19,11 +23,16 @@
 	Message string
 }
 
-type Response struct {
+type ResponseBody struct {
 	Errors string
 	Events []Event
 }
 
+type CachedResponse struct {
+	Status int
+	Body   ResponseBody
+}
+
 var (
 	// This channel is closed when the server begins shutting down.
 	// No values are ever sent to it.
@@ -33,6 +42,14 @@
 
 	// Note, shutdown triggers on SIGTERM or when the time limit is hit.
 	shutdown = flag.Bool("shutdown", true, "whether to ever shutdown the machine")
+
+	// Maximum request and response size. Same limit imposed by the go-tour.
+	maxSize = 1 << 16
+
+	// In-memory LRU cache of request/response bodies. Keys are sha1 sum of
+	// request bodies (20 bytes each), values are of type CachedResponse.
+	// TODO(nlacasse): Figure out the optimal number of entries. Using 10k for now.
+	cache = lru.New(10000)
 )
 
 func healthz(w http.ResponseWriter, r *http.Request) {
@@ -64,9 +81,35 @@
 		return
 	}
 
+	requestBody := streamToBytes(r.Body)
+
+	if len(requestBody) > maxSize {
+		responseBody := new(ResponseBody)
+		responseBody.Errors = "Program too large."
+		respondWithBody(w, http.StatusBadRequest, responseBody)
+		return
+	}
+
+	// Hash the body and see if it's been cached. If so, return the cached
+	// response status and body.
+	requestBodyHash := sha1.Sum(requestBody)
+	if cachedResponse, ok := cache.Get(requestBodyHash); ok {
+		if cachedResponseStruct, ok := cachedResponse.(CachedResponse); ok {
+			respondWithBody(w, cachedResponseStruct.Status, cachedResponseStruct.Body)
+			return
+		} else {
+			fmt.Println("Invalid cached response: %v", cachedResponse)
+			cache.Remove(requestBodyHash)
+		}
+	}
+
+	// TODO(nlacasse): It would be cool if we could stream the output
+	// messages while the process is running, rather than waiting for it to
+	// exit and dumping all the output then.
+
 	id := <-uniq
 	cmd := Docker("run", "-i", "--name", id, "playground")
-	cmd.Stdin = r.Body
+	cmd.Stdin = bytes.NewReader(requestBody)
 	buf := new(bytes.Buffer)
 	cmd.Stdout = buf
 	cmd.Stderr = buf
@@ -83,12 +126,40 @@
 	}
 	Docker("rm", "-f", id).Run()
 
-	response := new(Response)
-	response.Events = append(response.Events, Event{0, buf.String()})
-	body, _ := json.Marshal(response)
+	// If the response is bigger than the limit, cache the response and return an error.
+	if buf.Len() > maxSize {
+		status := http.StatusBadRequest
+		responseBody := new(ResponseBody)
+		responseBody.Errors = "Program output too large."
+		cache.Add(requestBodyHash, CachedResponse{
+			Status: status,
+			Body:   *responseBody,
+		})
+		respondWithBody(w, status, responseBody)
+		return
+	}
+
+	responseBody := new(ResponseBody)
+	responseBody.Events = append(responseBody.Events, Event{0, buf.String()})
+
+	cache.Add(requestBodyHash, CachedResponse{
+		Status: http.StatusOK,
+		Body:   *responseBody,
+	})
+	respondWithBody(w, http.StatusOK, responseBody)
+}
+
+func respondWithBody(w http.ResponseWriter, status int, body interface{}) {
+	bodyJson, _ := json.Marshal(body)
 	w.Header().Add("Content-Type", "application/json")
-	w.Header().Add("Content-Length", fmt.Sprintf("%d", len(body)))
-	w.Write(body)
+	w.Header().Add("Content-Length", fmt.Sprintf("%d", len(bodyJson)))
+	w.Write(bodyJson)
+}
+
+func streamToBytes(stream io.Reader) []byte {
+	buf := new(bytes.Buffer)
+	buf.ReadFrom(stream)
+	return buf.Bytes()
 }
 
 func Docker(args ...string) *exec.Cmd {