diff --git a/README.md b/README.md
index 4916e33d..98fbeb0e 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,10 @@ Using Chrome:
 
     /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --user-data-dir=/tmp/chrome --no-proxy-server --enable-quic --origin-to-force-quic-on=quic.clemente.io:443 --host-resolver-rules='MAP quic.clemente.io:443 127.0.0.1:6121' https://quic.clemente.io
 
+### QUIC without HTTP/2
+
+Take a look at [this echo example](example/echo/echo.go).
+
 ### Using the example client
 
     go run example/client/main.go https://clemente.io
diff --git a/example/echo/echo.go b/example/echo/echo.go
new file mode 100644
index 00000000..d8215ad5
--- /dev/null
+++ b/example/echo/echo.go
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
+	"io"
+	"log"
+	"math/big"
+
+	quic "github.com/lucas-clemente/quic-go"
+)
+
+const addr = "localhost:4242"
+
+const message = "foobar"
+
+// We start a server echoing data on the first stream the client opens,
+// then connect with a client, send the message, and wait for its receipt.
+func main() {
+	go func() { log.Fatal(echoServer()) }()
+
+	err := clientMain()
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Start a server that echos all data on the first stream opened by the client
+func echoServer() error {
+	cfgServer := &quic.Config{
+		TLSConfig: generateTLSConfig(),
+		ConnState: func(sess quic.Session, cs quic.ConnState) {
+			// Ignore unless the handshake is finished
+			if cs != quic.ConnStateForwardSecure {
+				return
+			}
+			go func() {
+				stream, err := sess.AcceptStream()
+				if err != nil {
+					panic(err)
+				}
+				// Echo through the loggingWriter
+				go io.Copy(loggingWriter{stream}, stream)
+			}()
+		},
+	}
+	listener, err := quic.ListenAddr(addr, cfgServer)
+	if err != nil {
+		return err
+	}
+	return listener.Serve()
+}
+
+func clientMain() error {
+	cfgClient := &quic.Config{
+		TLSConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+	session, err := quic.DialAddr(addr, cfgClient)
+	if err != nil {
+		return err
+	}
+
+	stream, err := session.OpenStreamSync()
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Client: Sending '%s'\n", message)
+	_, err = stream.Write([]byte(message))
+	if err != nil {
+		return err
+	}
+
+	buf := make([]byte, len(message))
+	_, err = io.ReadFull(stream, buf)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Client: Got '%s'\n", buf)
+
+	return nil
+}
+
+// A wrapper for io.Writer that also logs the message.
+type loggingWriter struct{ io.Writer }
+
+func (w loggingWriter) Write(b []byte) (int, error) {
+	fmt.Printf("Server: Got '%s'\n", string(b))
+	return w.Writer.Write(b)
+}
+
+// Setup a bare-bones TLS config for the server
+func generateTLSConfig() *tls.Config {
+	key, err := rsa.GenerateKey(rand.Reader, 1024)
+	if err != nil {
+		panic(err)
+	}
+	template := x509.Certificate{SerialNumber: big.NewInt(1)}
+	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
+	if err != nil {
+		panic(err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
+
+	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
+	if err != nil {
+		panic(err)
+	}
+	return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
+}