diff --git a/driver.go b/driver.go
index e65f69a..d32bec8 100644
--- a/driver.go
+++ b/driver.go
@@ -6,6 +6,8 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"path"
+	"testing"
 
 	_ "github.com/glebarez/go-sqlite"
 	_ "github.com/lib/pq"
@@ -15,6 +17,15 @@ type Driver struct {
 	*sql.DB
 }
 
+func NewTestDriver(t *testing.T) Driver {
+	driver, err := NewDriver(context.Background(), path.Join(t.TempDir(), "db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { driver.Close() })
+	return driver
+}
+
 func NewDriver(ctx context.Context, conn string) (Driver, error) {
 	engine := "sqlite"
 	if conn == "" {
diff --git a/driver_test.go b/driver_test.go
index 76af8bb..24f1a0c 100644
--- a/driver_test.go
+++ b/driver_test.go
@@ -6,6 +6,10 @@ import (
 	"time"
 )
 
+func TestNewTestDriver(t *testing.T) {
+	NewTestDriver(t)
+}
+
 func TestDriver(t *testing.T) {
 	ctx, can := context.WithTimeout(context.Background(), time.Second*15)
 	defer can()
diff --git a/main_test.go b/main_test.go
index 5abcef9..96df29e 100644
--- a/main_test.go
+++ b/main_test.go
@@ -43,7 +43,7 @@ func TestRun(t *testing.T) {
 	cfg.AssetPattern = renderAssetPattern
 	cfg.EventNamePattern = renderEventNamePattern
 	cfg.Port = port
-	cfg.driver, _ = NewDriver(ctx, "")
+	cfg.driver = NewTestDriver(t)
 	cfg.slackToMessagePipeline, _ = NewSlackToMessagePipeline(ctx, cfg)
 	cfg.SlackToken = "redacted"
 	cfg.SlackChannels = []string{"C06U1DDBBU4"}
diff --git a/persistence.go b/persistence.go
index 21a832b..fc84f6b 100644
--- a/persistence.go
+++ b/persistence.go
@@ -2,7 +2,7 @@ package main
 
 import (
 	"context"
-	"fmt"
+	"io"
 )
 
 type MessageToPersistence struct {
@@ -10,27 +10,23 @@ type MessageToPersistence struct {
 }
 
 func NewMessageToPersistencePipeline(ctx context.Context, cfg Config) (Pipeline, error) {
-	reader, err := NewQueue(ctx, "fromSlack", cfg.driver)
+	reader, err := NewQueue(ctx, "fromMessage", cfg.driver)
 	if err != nil {
 		return Pipeline{}, err
 	}
-	writer, err := NewQueue(ctx, "fromMessage", cfg.driver)
+	writer, err := NewQueue(ctx, "fromPersistence", cfg.driver)
 	if err != nil {
 		return Pipeline{}, err
 	}
 	return Pipeline{
 		writer:  writer,
 		reader:  reader,
-		process: newMessageToPersistenceProcess(cfg),
+		process: newMessageToPersistenceProcess(cfg.driver),
 	}, nil
 }
 
-func newMessageToPersistenceProcess(cfg Config) processFunc {
+func newMessageToPersistenceProcess(driver Driver) processFunc {
 	return func(ctx context.Context, slack []byte) ([]byte, error) {
-		m, err := ParseSlack(slack, cfg.AssetPattern, cfg.DatacenterPattern, cfg.EventNamePattern)
-		if err != nil {
-			return nil, fmt.Errorf("failed to deserialize slack %w: %s", err, slack)
-		}
-		return m.Serialize(), nil
+		return nil, io.EOF
 	}
 }
diff --git a/persistence_test.go b/persistence_test.go
new file mode 100644
index 0000000..85ec535
--- /dev/null
+++ b/persistence_test.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestMessageToPersistenceProcessor(t *testing.T) {
+	ctx, can := context.WithTimeout(context.Background(), time.Second*10)
+	defer can()
+
+	cases := map[string]string{}
+
+	for given, wantd := range cases {
+		want := wantd
+		t.Run(given, func(t *testing.T) {
+			process := newMessageToPersistenceProcess(NewTestDriver(t))
+
+			if got, err := process(ctx, []byte(given)); err != nil {
+				t.Fatal(err)
+			} else if string(got) != string(want) {
+				t.Errorf("wanted %q but got %q", want, got)
+			}
+		})
+	}
+}
diff --git a/pipeline_test.go b/pipeline_test.go
index 5c0622a..ae4601f 100644
--- a/pipeline_test.go
+++ b/pipeline_test.go
@@ -10,13 +10,11 @@ func TestPipeline(t *testing.T) {
 	ctx, can := context.WithTimeout(context.Background(), time.Second*10)
 	defer can()
 
-	driverOutput, _ := NewDriver(ctx, "")
-	output, err := NewQueue(ctx, "output", driverOutput)
+	output, err := NewQueue(ctx, "output", NewTestDriver(t))
 	if err != nil {
 		t.Fatal(err)
 	}
-	driverInput, _ := NewDriver(ctx, "")
-	input, err := NewQueue(ctx, "input", driverInput)
+	input, err := NewQueue(ctx, "input", NewTestDriver(t))
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/queue_test.go b/queue_test.go
index dfbb328..8d20472 100644
--- a/queue_test.go
+++ b/queue_test.go
@@ -11,12 +11,11 @@ func TestQueue(t *testing.T) {
 	ctx, can := context.WithTimeout(context.Background(), time.Second*10)
 	defer can()
 
-	driver, _ := NewDriver(ctx, "")
-	q, err := NewQueue(ctx, "", driver)
+	q, err := NewQueue(ctx, "", NewTestDriver(t))
 	if err != nil {
 		t.Fatal(err)
 	}
-	qOther, _ := NewQueue(ctx, "other", driver)
+	qOther, _ := NewQueue(ctx, "other", q.driver)
 
 	if reservation, _, err := q.syn(ctx); reservation != nil {
 		t.Errorf("able to syn before any enqueues created: %v", err)
diff --git a/slack_test.go b/slack_test.go
index c90ce42..cb2b8c8 100644
--- a/slack_test.go
+++ b/slack_test.go
@@ -13,8 +13,7 @@ func TestSlackToMessagePipeline(t *testing.T) {
 	ctx, can := context.WithTimeout(context.Background(), time.Second*5)
 	defer can()
 
-	driver, _ := NewDriver(ctx, "/tmp/f")
-	pipeline, err := NewSlackToMessagePipeline(ctx, Config{driver: driver})
+	pipeline, err := NewSlackToMessagePipeline(ctx, Config{driver: NewTestDriver(t)})
 	if err != nil {
 		t.Fatal(err)
 	}