diff --git a/cmd/frontend/main.go b/cmd/frontend/main.go
index d2a4fd1..145f493 100644
--- a/cmd/frontend/main.go
+++ b/cmd/frontend/main.go
@@ -22,6 +22,7 @@
 	"golang.org/x/pkgsite/internal/fetch"
 	"golang.org/x/pkgsite/internal/fetchdatasource"
 	"golang.org/x/pkgsite/internal/frontend"
+	"golang.org/x/pkgsite/internal/frontend/fetchserver"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/middleware"
 	"golang.org/x/pkgsite/internal/middleware/timeout"
@@ -100,7 +101,7 @@
 		// per-request connection.
 		fetchQueue, err = gcpqueue.New(ctx, cfg, queueName, *workers, expg,
 			func(ctx context.Context, modulePath, version string) (int, error) {
-				return frontend.FetchAndUpdateState(ctx, modulePath, version, proxyClient, sourceClient, db)
+				return fetchserver.FetchAndUpdateState(ctx, modulePath, version, proxyClient, sourceClient, db)
 			})
 		if err != nil {
 			log.Fatalf(ctx, "gcpqueue.New: %v", err)
@@ -115,7 +116,7 @@
 	staticSource := template.TrustedSourceFromFlag(flag.Lookup("static").Value)
 	// TODO: Can we use a separate queue for the fetchServer and for the Server?
 	// It would help differentiate ownership.
-	fetchServer := &frontend.FetchServer{
+	fetchServer := &fetchserver.FetchServer{
 		Queue:                fetchQueue,
 		TaskIDChangeInterval: config.TaskIDChangeIntervalFrontend,
 	}
@@ -154,8 +155,8 @@
 	views := append(dcensus.ServerViews,
 		postgres.SearchLatencyDistribution,
 		postgres.SearchResponseCount,
-		frontend.FetchLatencyDistribution,
-		frontend.FetchResponseCount,
+		fetchserver.FetchLatencyDistribution,
+		fetchserver.FetchResponseCount,
 		frontend.VersionTypeCount,
 		middleware.CacheResultCount,
 		middleware.CacheErrorCount,
diff --git a/internal/frontend/breadcrumb.go b/internal/frontend/breadcrumb.go
index 34c29f5..9277516 100644
--- a/internal/frontend/breadcrumb.go
+++ b/internal/frontend/breadcrumb.go
@@ -8,6 +8,7 @@
 	"path"
 
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
 )
@@ -69,7 +70,7 @@
 	for i := 1; i < len(dirs); i++ {
 		href := "/" + dirs[i]
 		if requestedVersion != version.Latest {
-			href += "@" + linkVersion(modPath, requestedVersion, requestedVersion)
+			href += "@" + versions.LinkVersion(modPath, requestedVersion, requestedVersion)
 		}
 		el := dirs[i]
 		if i != len(dirs)-1 {
diff --git a/internal/frontend/client.go b/internal/frontend/client.go
index 978c87b..36b7741 100644
--- a/internal/frontend/client.go
+++ b/internal/frontend/client.go
@@ -14,6 +14,7 @@
 
 	"golang.org/x/pkgsite/internal/auth"
 	"golang.org/x/pkgsite/internal/derrors"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 )
 
 // A Client for interacting with the frontend. This is only used for tests.
@@ -40,14 +41,14 @@
 
 // GetVersions returns a VersionsDetails for the specified pkgPath.
 // This is only used for tests.
-func (c *Client) GetVersions(pkgPath string) (_ *VersionsDetails, err error) {
+func (c *Client) GetVersions(pkgPath string) (_ *versions.VersionsDetails, err error) {
 	defer derrors.Wrap(&err, "GetVersions(%q)", pkgPath)
 	u := fmt.Sprintf("%s/%s?tab=versions&content=json", c.url, pkgPath)
 	body, err := c.fetchJSONPage(u)
 	if err != nil {
 		return nil, err
 	}
-	var vd VersionsDetails
+	var vd versions.VersionsDetails
 	if err := json.Unmarshal(body, &vd); err != nil {
 		return nil, fmt.Errorf("json.Unmarshal: %v:\nDoes GO_DISCOVERY_SERVE_STATS=true on the frontend?", err)
 	}
diff --git a/internal/frontend/details.go b/internal/frontend/details.go
index 1aac1ee..7870b98 100644
--- a/internal/frontend/details.go
+++ b/internal/frontend/details.go
@@ -15,7 +15,6 @@
 	"golang.org/x/pkgsite/internal/frontend/urlinfo"
 	mstats "golang.org/x/pkgsite/internal/middleware/stats"
 
-	"github.com/google/safehtml/template"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/stats/view"
 	"go.opencensus.io/tag"
@@ -65,7 +64,7 @@
 		}
 	}
 	if !urlinfo.IsSupportedVersion(urlInfo.FullPath, urlInfo.RequestedVersion) {
-		return invalidVersionError(urlInfo.FullPath, urlInfo.RequestedVersion)
+		return serrors.InvalidVersionError(urlInfo.FullPath, urlInfo.RequestedVersion)
 	}
 	if urlPath := stdlibRedirectURL(urlInfo.FullPath); urlPath != "" {
 		http.Redirect(w, r, urlPath, http.StatusMovedPermanently)
@@ -91,30 +90,6 @@
 	return "/" + urlPath2
 }
 
-func invalidVersionError(fullPath, requestedVersion string) error {
-	return &serrors.ServerError{
-		Status: http.StatusBadRequest,
-		Epage: &page.ErrorPage{
-			MessageTemplate: template.MakeTrustedTemplate(`
-					<h3 class="Error-message">{{.Version}} is not a valid semantic version.</h3>
-					<p class="Error-message">
-					  To search for packages like {{.Path}}, <a href="/search?q={{.Path}}">click here</a>.
-					</p>`),
-			MessageData: struct{ Path, Version string }{fullPath, requestedVersion},
-		},
-	}
-}
-
-func datasourceNotSupportedErr() error {
-	return &serrors.ServerError{
-		Status: http.StatusFailedDependency,
-		Epage: &page.ErrorPage{
-			MessageTemplate: template.MakeTrustedTemplate(
-				`<h3 class="Error-message">This page is not supported by this datasource.</h3>`),
-		},
-	}
-}
-
 var (
 	keyVersionType     = tag.MustNewKey("frontend.version_type")
 	versionTypeResults = stats.Int64(
diff --git a/internal/frontend/directory.go b/internal/frontend/directory.go
index b809d88..fa1fd08 100644
--- a/internal/frontend/directory.go
+++ b/internal/frontend/directory.go
@@ -10,6 +10,7 @@
 	"strings"
 
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
 )
@@ -104,7 +105,7 @@
 			continue
 		}
 		mods = append(mods, &DirectoryInfo{
-			URL:      constructUnitURL(m.ModulePath, m.ModulePath, version.Latest),
+			URL:      versions.ConstructUnitURL(m.ModulePath, m.ModulePath, version.Latest),
 			Suffix:   suffix,
 			IsModule: true,
 		})
@@ -125,8 +126,8 @@
 			continue
 		}
 		sdirs = append(sdirs, &DirectoryInfo{
-			URL: constructUnitURL(pm.Path, um.ModulePath,
-				linkVersion(um.ModulePath, requestedVersion, um.Version)),
+			URL: versions.ConstructUnitURL(pm.Path, um.ModulePath,
+				versions.LinkVersion(um.ModulePath, requestedVersion, um.Version)),
 			Suffix:   internal.Suffix(pm.Path, um.Path),
 			Synopsis: pm.Synopsis,
 		})
diff --git a/internal/frontend/404.go b/internal/frontend/fetchserver/404.go
similarity index 90%
rename from internal/frontend/404.go
rename to internal/frontend/fetchserver/404.go
index 958701a..915ec9c 100644
--- a/internal/frontend/404.go
+++ b/internal/frontend/fetchserver/404.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package fetchserver
 
 import (
 	"context"
@@ -15,7 +15,6 @@
 	"strings"
 	"time"
 
-	"github.com/google/safehtml/template"
 	"github.com/google/safehtml/template/uncheckedconversions"
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/cookie"
@@ -24,25 +23,12 @@
 	"golang.org/x/pkgsite/internal/frontend/page"
 	"golang.org/x/pkgsite/internal/frontend/serrors"
 	"golang.org/x/pkgsite/internal/frontend/urlinfo"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
 )
 
-// errUnitNotFoundWithoutFetch returns a 404 with instructions to the user on
-// how to manually fetch the package. No fetch button is provided. This is used
-// for very large modules or modules that previously 500ed.
-var errUnitNotFoundWithoutFetch = &serrors.ServerError{
-	Status: http.StatusNotFound,
-	Epage: &page.ErrorPage{
-		MessageTemplate: template.MakeTrustedTemplate(`
-					    <h3 class="Error-message">{{.StatusText}}</h3>
-					    <p class="Error-message">Check that you entered the URL correctly or try fetching it following the
-                        <a href="/about#adding-a-package">instructions here</a>.</p>`),
-		MessageData: struct{ StatusText string }{http.StatusText(http.StatusNotFound)},
-	},
-}
-
 // servePathNotFoundPage serves a 404 page for the requested path, or redirects
 // the user to an appropriate location.
 func (s *FetchServer) ServePathNotFoundPage(w http.ResponseWriter, r *http.Request,
@@ -98,7 +84,7 @@
 		// We will only reach a 2xx status if we found a row in version_map
 		// matching exactly the requested path.
 		if fr.resolvedVersion != requestedVersion {
-			u := constructUnitURL(fullPath, fr.goModPath, fr.resolvedVersion)
+			u := versions.ConstructUnitURL(fullPath, fr.goModPath, fr.resolvedVersion)
 			http.Redirect(w, r, u, http.StatusFound)
 			return
 		}
@@ -115,16 +101,16 @@
 		if fr.goModPath == fullPath {
 			// The redirectPath and the fullpath are the same. Do not redirect
 			// to avoid ending up in a loop.
-			return errUnitNotFoundWithoutFetch
+			return serrors.ErrUnitNotFoundWithoutFetch
 		}
 		vm, err := db.GetVersionMap(ctx, fr.goModPath, version.Latest)
 		if (err != nil && !errors.Is(err, derrors.NotFound)) ||
 			(vm != nil && vm.Status != http.StatusOK) {
 			// We attempted to fetch the canonical module path before and were
 			// not successful. Do not redirect this request.
-			return errUnitNotFoundWithoutFetch
+			return serrors.ErrUnitNotFoundWithoutFetch
 		}
-		u := constructUnitURL(fr.goModPath, fr.goModPath, version.Latest)
+		u := versions.ConstructUnitURL(fr.goModPath, fr.goModPath, version.Latest)
 		cookie.Set(w, cookie.AlternativeModuleFlash, fullPath, u)
 		http.Redirect(w, r, u, http.StatusFound)
 		return nil
@@ -178,14 +164,14 @@
 	if m[1] != "" {
 		p = m[0] + m[1]
 	}
-	return constructUnitURL(p, p, version.Latest)
+	return versions.ConstructUnitURL(p, p, version.Latest)
 }
 
 // pathNotFoundError returns a page with an option on how to
 // add a package or module to the site.
 func pathNotFoundError(ctx context.Context, fullPath, requestedVersion string) error {
 	if !urlinfo.IsSupportedVersion(fullPath, requestedVersion) {
-		return invalidVersionError(fullPath, requestedVersion)
+		return serrors.InvalidVersionError(fullPath, requestedVersion)
 	}
 	if stdlib.Contains(fullPath) {
 		if experiment.IsActive(ctx, internal.ExperimentEnableStdFrontendFetch) {
diff --git a/internal/frontend/404_test.go b/internal/frontend/fetchserver/404_test.go
similarity index 99%
rename from internal/frontend/404_test.go
rename to internal/frontend/fetchserver/404_test.go
index 145ca2a..a087613 100644
--- a/internal/frontend/404_test.go
+++ b/internal/frontend/fetchserver/404_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package fetchserver
 
 import (
 	"context"
diff --git a/internal/frontend/fetch.go b/internal/frontend/fetchserver/fetch.go
similarity index 99%
rename from internal/frontend/fetch.go
rename to internal/frontend/fetchserver/fetch.go
index dd725e6..038334b 100644
--- a/internal/frontend/fetch.go
+++ b/internal/frontend/fetchserver/fetch.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package fetchserver
 
 import (
 	"context"
@@ -101,7 +101,7 @@
 	defer derrors.Wrap(&err, "serveFetch(%q)", r.URL.Path)
 	if _, ok := ds.(internal.PostgresDB); !ok {
 		// There's no reason for other DataSources to need this codepath.
-		return datasourceNotSupportedErr()
+		return serrors.DatasourceNotSupportedError()
 	}
 	if r.Method != http.MethodPost {
 		// If a user makes a GET request, treat this as a request for the
diff --git a/internal/frontend/fetch_test.go b/internal/frontend/fetchserver/fetch_test.go
similarity index 76%
rename from internal/frontend/fetch_test.go
rename to internal/frontend/fetchserver/fetch_test.go
index 7a90a38..a4eb381 100644
--- a/internal/frontend/fetch_test.go
+++ b/internal/frontend/fetchserver/fetch_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package fetchserver
 
 import (
 	"context"
@@ -12,13 +12,19 @@
 	"time"
 
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/safehtml/template"
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
+	"golang.org/x/pkgsite/internal/frontend"
 	"golang.org/x/pkgsite/internal/postgres"
 	"golang.org/x/pkgsite/internal/proxy/proxytest"
+	"golang.org/x/pkgsite/internal/queue"
+	"golang.org/x/pkgsite/internal/source"
 	"golang.org/x/pkgsite/internal/testing/sample"
 	"golang.org/x/pkgsite/internal/testing/testhelper"
 	"golang.org/x/pkgsite/internal/version"
+	"golang.org/x/pkgsite/static"
+	thirdparty "golang.org/x/pkgsite/third_party"
 )
 
 var (
@@ -39,6 +45,45 @@
 	}
 )
 
+func newTestServerWithFetch(t *testing.T, proxyModules []*proxytest.Module, cacher frontend.Cacher) (*frontend.Server, *FetchServer, http.Handler, func()) {
+	t.Helper()
+	proxyClient, teardown := proxytest.SetupTestClient(t, proxyModules)
+	sourceClient := source.NewClient(sourceTimeout)
+	ctx := context.Background()
+
+	q := queue.NewInMemory(ctx, 1, nil,
+		func(ctx context.Context, mpath, version string) (int, error) {
+			return FetchAndUpdateState(ctx, mpath, version, proxyClient, sourceClient, testDB)
+		})
+
+	f := &FetchServer{
+		Queue:                q,
+		TaskIDChangeInterval: 10 * time.Minute,
+	}
+
+	s, err := frontend.NewServer(frontend.ServerConfig{
+		FetchServer:      f,
+		DataSourceGetter: func(context.Context) internal.DataSource { return testDB },
+		Queue:            q,
+		TemplateFS:       template.TrustedFSFromEmbed(static.FS),
+		// Use the embedded FSs here to make sure they're tested.
+		// Integration tests will use the actual directories.
+		StaticFS:     static.FS,
+		ThirdPartyFS: thirdparty.FS,
+		StaticPath:   "../../static",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mux := http.NewServeMux()
+	s.Install(mux.Handle, cacher, nil)
+
+	return s, f, mux, func() {
+		teardown()
+		postgres.ResetTestDB(testDB, t)
+	}
+}
+
 func TestFetch(t *testing.T) {
 	for _, test := range []struct {
 		name, fullPath, version, want string
@@ -80,13 +125,13 @@
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			s, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
+			_, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
 			defer teardown()
 
 			ctx, cancel := context.WithTimeout(context.Background(), testFetchTimeout)
 			defer cancel()
 
-			status, responseText := f.fetchAndPoll(ctx, s.getDataSource(ctx), testModulePath, test.fullPath, test.version)
+			status, responseText := f.fetchAndPoll(ctx, testDB, testModulePath, test.fullPath, test.version)
 			if status != http.StatusOK {
 				t.Fatalf("fetchAndPoll(%q, %q, %q) = %d, %s; want status = %d",
 					testModulePath, test.fullPath, test.version, status, responseText, http.StatusOK)
@@ -144,9 +189,9 @@
 			ctx, cancel := context.WithTimeout(context.Background(), test.fetchTimeout)
 			defer cancel()
 
-			s, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
+			_, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
 			defer teardown()
-			got, err := f.fetchAndPoll(ctx, s.getDataSource(ctx), test.modulePath, test.fullPath, test.version)
+			got, err := f.fetchAndPoll(ctx, testDB, test.modulePath, test.fullPath, test.version)
 
 			if got != test.want {
 				t.Fatalf("fetchAndPoll(ctx, testDB, q, %q, %q, %q): %d; want = %d",
@@ -181,9 +226,9 @@
 				t.Fatal(err)
 			}
 
-			s, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
+			_, f, _, teardown := newTestServerWithFetch(t, testModulesForProxy, nil)
 			defer teardown()
-			got, _ := f.fetchAndPoll(ctx, s.getDataSource(ctx), sample.ModulePath, sample.PackagePath, sample.VersionString)
+			got, _ := f.fetchAndPoll(ctx, testDB, sample.ModulePath, sample.PackagePath, sample.VersionString)
 			if got != test.want {
 				t.Fatalf("fetchAndPoll for status %d: %d; want = %d)", test.status, got, test.want)
 			}
diff --git a/internal/frontend/fetchserver/frontend_test.go b/internal/frontend/fetchserver/frontend_test.go
new file mode 100644
index 0000000..ab13c12
--- /dev/null
+++ b/internal/frontend/fetchserver/frontend_test.go
@@ -0,0 +1,83 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fetchserver
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/postgres"
+	"golang.org/x/pkgsite/internal/source"
+	"golang.org/x/pkgsite/internal/testing/sample"
+)
+
+const testTimeout = 5 * time.Second
+
+var testDB *postgres.DB
+
+func TestMain(m *testing.M) {
+	postgres.RunDBTests("discovery_fetchserver_test", m, &testDB)
+}
+
+type testModule struct {
+	path            string
+	redistributable bool
+	versions        []string
+	packages        []testPackage
+}
+
+type testPackage struct {
+	name           string
+	suffix         string
+	readmeContents string
+	readmeFilePath string
+	docs           []*internal.Documentation
+}
+
+func insertTestModules(ctx context.Context, t *testing.T, mods []testModule) {
+	for _, mod := range mods {
+		var (
+			suffixes []string
+			pkgs     = make(map[string]testPackage)
+		)
+		for _, pkg := range mod.packages {
+			suffixes = append(suffixes, pkg.suffix)
+			pkgs[pkg.suffix] = pkg
+		}
+		for _, ver := range mod.versions {
+			m := sample.Module(mod.path, ver, suffixes...)
+			m.SourceInfo = source.NewGitHubInfo(sample.RepositoryURL, "", ver)
+			m.IsRedistributable = mod.redistributable
+			if !m.IsRedistributable {
+				m.Licenses = nil
+			}
+			for _, u := range m.Units {
+				if pkg, ok := pkgs[internal.Suffix(u.Path, m.ModulePath)]; ok {
+					if pkg.name != "" {
+						u.Name = pkg.name
+					}
+					if pkg.readmeContents != "" {
+						u.Readme = &internal.Readme{
+							Contents: pkg.readmeContents,
+							Filepath: pkg.readmeFilePath,
+						}
+					}
+					if pkg.docs != nil {
+						u.Documentation = pkg.docs
+					}
+				}
+				if !mod.redistributable {
+					u.IsRedistributable = false
+					u.Licenses = nil
+					u.Documentation = nil
+					u.Readme = nil
+				}
+			}
+			postgres.MustInsertModule(ctx, t, testDB, m)
+		}
+	}
+}
diff --git a/internal/frontend/server_test.go b/internal/frontend/fetchserver/server_test.go
similarity index 86%
rename from internal/frontend/server_test.go
rename to internal/frontend/fetchserver/server_test.go
index f566ab0..69c998d 100644
--- a/internal/frontend/server_test.go
+++ b/internal/frontend/fetchserver/server_test.go
@@ -2,12 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// github.com/alicebob/miniredis/v2 pulls in
-// github.com/yuin/gopher-lua which uses a non
-// build-tag-guarded use of the syscall package.
-//go:build !plan9
-
-package frontend
+package fetchserver
 
 import (
 	"context"
@@ -17,31 +12,17 @@
 	"net/http/httptest"
 	"os"
 	"regexp"
-	"strings"
 	"testing"
 	"time"
 
-	"github.com/google/safehtml/template"
-	"github.com/jba/templatecheck"
 	"golang.org/x/net/html"
 	"golang.org/x/pkgsite/internal"
-	"golang.org/x/pkgsite/internal/frontend/page"
 	"golang.org/x/pkgsite/internal/postgres"
 	"golang.org/x/pkgsite/internal/testing/htmlcheck"
 	"golang.org/x/pkgsite/internal/testing/pagecheck"
 	"golang.org/x/pkgsite/internal/testing/sample"
-	"golang.org/x/pkgsite/static"
 )
 
-func TestHTMLInjection(t *testing.T) {
-	_, handler, _ := newTestServer(t, nil, nil)
-	w := httptest.NewRecorder()
-	handler.ServeHTTP(w, httptest.NewRequest("GET", "/<em>UHOH</em>", nil))
-	if strings.Contains(w.Body.String(), "<em>") {
-		t.Error("User input was rendered unescaped.")
-	}
-}
-
 const pseudoVersion = "v0.0.0-20140414041502-123456789012"
 
 type serverTestCase struct {
@@ -1169,160 +1150,16 @@
 	return c(doc)
 }
 
-func mustRequest(urlPath string, t *testing.T) *http.Request {
-	t.Helper()
-	r, err := http.NewRequest(http.MethodGet, "http://localhost"+urlPath, nil)
-	if err != nil {
-		t.Fatal(err)
+// absoluteTime takes a date and returns a human-readable,
+// date with the format mmm d, yyyy.
+// This is a copy of internal/frontend.absoluteTime.
+func absoluteTime(date time.Time) string {
+	if date.IsZero() {
+		return "unknown"
 	}
-	return r
-}
-
-func TestDetailsTTL(t *testing.T) {
-	tests := []struct {
-		r    *http.Request
-		want time.Duration
-	}{
-		{mustRequest("/host.com/module@v1.2.3/suffix", t), longTTL},
-		{mustRequest("/host.com/module/suffix", t), shortTTL},
-		{mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t), longTTL},
-		{mustRequest("/host.com/module@v1.2.3/suffix?tab=versions", t), defaultTTL},
-		{mustRequest("/host.com/module@v1.2.3/suffix?tab=importedby", t), defaultTTL},
-		{
-			func() *http.Request {
-				r := mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t)
-				r.Header.Set("user-agent",
-					"Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)")
-				return r
-			}(),
-			tinyTTL,
-		},
-	}
-	for _, test := range tests {
-		if got := detailsTTL(test.r); got != test.want {
-			t.Errorf("detailsTTL(%v) = %v, want %v", test.r, got, test.want)
-		}
-	}
-}
-
-func TestTagRoute(t *testing.T) {
-	mustRequest := func(url string) *http.Request {
-		req, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return req
-	}
-	tests := []struct {
-		route string
-		req   *http.Request
-		want  string
-	}{
-		{"/pkg", mustRequest("http://localhost/pkg/foo?tab=versions"), "pkg-versions"},
-		{"/", mustRequest("http://localhost/foo?tab=imports"), "imports"},
-		{"/search", mustRequest("http://localhost/search?q=net&m=vuln"), "search-vuln"},
-		{"/search", mustRequest("http://localhost/search?q=net&m=package"), "search-package"},
-		{"/search", mustRequest("http://localhost/search?q=net&m=symbol"), "search-symbol"},
-		{"/search", mustRequest("http://localhost/search?q=net"), "search-package"},
-	}
-	for _, test := range tests {
-		t.Run(test.want, func(t *testing.T) {
-			if got := TagRoute(test.route, test.req); got != test.want {
-				t.Errorf("TagRoute(%q, %v) = %q, want %q", test.route, test.req, got, test.want)
-			}
-		})
-	}
-}
-
-func TestCheckTemplates(t *testing.T) {
-	// Perform additional checks on parsed templates.
-	staticFS := template.TrustedFSFromEmbed(static.FS)
-	templates, err := parsePageTemplates(staticFS)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, c := range []struct {
-		name    string
-		subs    []string
-		typeval any
-	}{
-		{"badge", nil, badgePage{}},
-		// error.tmpl omitted because relies on an associated "message" template
-		// that's parsed on demand; see renderErrorPage above.
-		{"fetch", nil, page.ErrorPage{}},
-		{"homepage", nil, homepage{}},
-		{"license-policy", nil, licensePolicyPage{}},
-		{"search", nil, SearchPage{}},
-		{"search-help", nil, page.BasePage{}},
-		{"unit/main", nil, UnitPage{}},
-		{
-			"unit/main",
-			[]string{"unit-outline", "unit-readme", "unit-doc", "unit-files", "unit-directories"},
-			MainDetails{},
-		},
-		{"unit/importedby", nil, UnitPage{}},
-		{"unit/importedby", []string{"importedby"}, ImportedByDetails{}},
-		{"unit/imports", nil, UnitPage{}},
-		{"unit/imports", []string{"imports"}, ImportsDetails{}},
-		{"unit/licenses", nil, UnitPage{}},
-		{"unit/licenses", []string{"licenses"}, LicensesDetails{}},
-		{"unit/versions", nil, UnitPage{}},
-		{"unit/versions", []string{"versions"}, VersionsDetails{}},
-		{"vuln", nil, page.BasePage{}},
-		{"vuln/list", nil, VulnListPage{}},
-		{"vuln/entry", nil, VulnEntryPage{}},
-	} {
-		t.Run(c.name, func(t *testing.T) {
-			tm := templates[c.name]
-			if tm == nil {
-				t.Fatalf("no template %q", c.name)
-			}
-			if c.subs == nil {
-				if err := templatecheck.CheckSafe(tm, c.typeval); err != nil {
-					t.Fatal(err)
-				}
-			} else {
-				for _, n := range c.subs {
-					s := tm.Lookup(n)
-					if s == nil {
-						t.Fatalf("no sub-template %q of %q", n, c.name)
-					}
-					if err := templatecheck.CheckSafe(s, c.typeval); err != nil {
-						t.Fatalf("%s: %v", n, err)
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestStripScheme(t *testing.T) {
-	for _, test := range []struct {
-		url, want string
-	}{
-		{"http://github.com", "github.com"},
-		{"https://github.com/path/to/something", "github.com/path/to/something"},
-		{"example.com", "example.com"},
-		{"chrome-extension://abcd", "abcd"},
-		{"nonwellformed.com/path?://query=1", "query=1"},
-	} {
-		if got := stripScheme(test.url); got != test.want {
-			t.Errorf("%q: got %q, want %q", test.url, got, test.want)
-		}
-	}
-}
-
-func TestInstallFS(t *testing.T) {
-	s, handler, teardown := newTestServer(t, nil, nil)
-	defer teardown()
-	s.InstallFS("/dir", os.DirFS("."))
-	// Request this file.
-	w := httptest.NewRecorder()
-	handler.ServeHTTP(w, httptest.NewRequest("GET", "/files/dir/server_test.go", nil))
-	if w.Code != http.StatusOK {
-		t.Errorf("got status code = %d, want %d", w.Code, http.StatusOK)
-	}
-	if want := "TestInstallFS"; !strings.Contains(w.Body.String(), want) {
-		t.Errorf("body does not contain %q", want)
-	}
+	// Convert to UTC because that is how the date is represented in the DB.
+	// (The pgx driver returns local times.) Example: if a date is stored
+	// as Jan 30 at midnight, then the local NYC time is on Jan 29, and this
+	// function would return "Jan 29" instead of the correct "Jan 30".
+	return date.In(time.UTC).Format("Jan _2, 2006")
 }
diff --git a/internal/frontend/frontend_test.go b/internal/frontend/frontend_test.go
index 0c2c411..1bb7e25 100644
--- a/internal/frontend/frontend_test.go
+++ b/internal/frontend/frontend_test.go
@@ -7,16 +7,19 @@
 import (
 	"context"
 	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/google/safehtml/template"
+	"github.com/jba/templatecheck"
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/page"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/postgres"
 	"golang.org/x/pkgsite/internal/proxy/proxytest"
-	"golang.org/x/pkgsite/internal/queue"
-	"golang.org/x/pkgsite/internal/source"
-	"golang.org/x/pkgsite/internal/testing/sample"
 	"golang.org/x/pkgsite/static"
 	thirdparty "golang.org/x/pkgsite/third_party"
 )
@@ -67,85 +70,169 @@
 	}
 }
 
-func newTestServerWithFetch(t *testing.T, proxyModules []*proxytest.Module, cacher Cacher) (*Server, *FetchServer, http.Handler, func()) {
-	t.Helper()
-	proxyClient, teardown := proxytest.SetupTestClient(t, proxyModules)
-	sourceClient := source.NewClient(sourceTimeout)
-	ctx := context.Background()
-
-	q := queue.NewInMemory(ctx, 1, nil,
-		func(ctx context.Context, mpath, version string) (int, error) {
-			return FetchAndUpdateState(ctx, mpath, version, proxyClient, sourceClient, testDB)
-		})
-
-	f := &FetchServer{
-		Queue:                q,
-		TaskIDChangeInterval: 10 * time.Minute,
-	}
-
-	s, err := NewServer(ServerConfig{
-		FetchServer:      f,
-		DataSourceGetter: func(context.Context) internal.DataSource { return testDB },
-		Queue:            q,
-		TemplateFS:       template.TrustedFSFromEmbed(static.FS),
-		// Use the embedded FSs here to make sure they're tested.
-		// Integration tests will use the actual directories.
-		StaticFS:     static.FS,
-		ThirdPartyFS: thirdparty.FS,
-		StaticPath:   "../../static",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	mux := http.NewServeMux()
-	s.Install(mux.Handle, cacher, nil)
-
-	return s, f, mux, func() {
-		teardown()
-		postgres.ResetTestDB(testDB, t)
+func TestHTMLInjection(t *testing.T) {
+	_, handler, _ := newTestServer(t, nil, nil)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, httptest.NewRequest("GET", "/<em>UHOH</em>", nil))
+	if strings.Contains(w.Body.String(), "<em>") {
+		t.Error("User input was rendered unescaped.")
 	}
 }
 
-func insertTestModules(ctx context.Context, t *testing.T, mods []testModule) {
-	for _, mod := range mods {
-		var (
-			suffixes []string
-			pkgs     = make(map[string]testPackage)
-		)
-		for _, pkg := range mod.packages {
-			suffixes = append(suffixes, pkg.suffix)
-			pkgs[pkg.suffix] = pkg
+func mustRequest(urlPath string, t *testing.T) *http.Request {
+	t.Helper()
+	r, err := http.NewRequest(http.MethodGet, "http://localhost"+urlPath, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return r
+}
+
+func TestDetailsTTL(t *testing.T) {
+	tests := []struct {
+		r    *http.Request
+		want time.Duration
+	}{
+		{mustRequest("/host.com/module@v1.2.3/suffix", t), longTTL},
+		{mustRequest("/host.com/module/suffix", t), shortTTL},
+		{mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t), longTTL},
+		{mustRequest("/host.com/module@v1.2.3/suffix?tab=versions", t), defaultTTL},
+		{mustRequest("/host.com/module@v1.2.3/suffix?tab=importedby", t), defaultTTL},
+		{
+			func() *http.Request {
+				r := mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t)
+				r.Header.Set("user-agent",
+					"Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)")
+				return r
+			}(),
+			tinyTTL,
+		},
+	}
+	for _, test := range tests {
+		if got := detailsTTL(test.r); got != test.want {
+			t.Errorf("detailsTTL(%v) = %v, want %v", test.r, got, test.want)
 		}
-		for _, ver := range mod.versions {
-			m := sample.Module(mod.path, ver, suffixes...)
-			m.SourceInfo = source.NewGitHubInfo(sample.RepositoryURL, "", ver)
-			m.IsRedistributable = mod.redistributable
-			if !m.IsRedistributable {
-				m.Licenses = nil
+	}
+}
+
+func TestTagRoute(t *testing.T) {
+	mustRequest := func(url string) *http.Request {
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return req
+	}
+	tests := []struct {
+		route string
+		req   *http.Request
+		want  string
+	}{
+		{"/pkg", mustRequest("http://localhost/pkg/foo?tab=versions"), "pkg-versions"},
+		{"/", mustRequest("http://localhost/foo?tab=imports"), "imports"},
+		{"/search", mustRequest("http://localhost/search?q=net&m=vuln"), "search-vuln"},
+		{"/search", mustRequest("http://localhost/search?q=net&m=package"), "search-package"},
+		{"/search", mustRequest("http://localhost/search?q=net&m=symbol"), "search-symbol"},
+		{"/search", mustRequest("http://localhost/search?q=net"), "search-package"},
+	}
+	for _, test := range tests {
+		t.Run(test.want, func(t *testing.T) {
+			if got := TagRoute(test.route, test.req); got != test.want {
+				t.Errorf("TagRoute(%q, %v) = %q, want %q", test.route, test.req, got, test.want)
 			}
-			for _, u := range m.Units {
-				if pkg, ok := pkgs[internal.Suffix(u.Path, m.ModulePath)]; ok {
-					if pkg.name != "" {
-						u.Name = pkg.name
+		})
+	}
+}
+
+func TestCheckTemplates(t *testing.T) {
+	// Perform additional checks on parsed templates.
+	staticFS := template.TrustedFSFromEmbed(static.FS)
+	templates, err := parsePageTemplates(staticFS)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range []struct {
+		name    string
+		subs    []string
+		typeval any
+	}{
+		{"badge", nil, badgePage{}},
+		// error.tmpl omitted because relies on an associated "message" template
+		// that's parsed on demand; see renderErrorPage above.
+		{"fetch", nil, page.ErrorPage{}},
+		{"homepage", nil, homepage{}},
+		{"license-policy", nil, licensePolicyPage{}},
+		{"search", nil, SearchPage{}},
+		{"search-help", nil, page.BasePage{}},
+		{"unit/main", nil, UnitPage{}},
+		{
+			"unit/main",
+			[]string{"unit-outline", "unit-readme", "unit-doc", "unit-files", "unit-directories"},
+			MainDetails{},
+		},
+		{"unit/importedby", nil, UnitPage{}},
+		{"unit/importedby", []string{"importedby"}, ImportedByDetails{}},
+		{"unit/imports", nil, UnitPage{}},
+		{"unit/imports", []string{"imports"}, ImportsDetails{}},
+		{"unit/licenses", nil, UnitPage{}},
+		{"unit/licenses", []string{"licenses"}, LicensesDetails{}},
+		{"unit/versions", nil, UnitPage{}},
+		{"unit/versions", []string{"versions"}, versions.VersionsDetails{}},
+		{"vuln", nil, page.BasePage{}},
+		{"vuln/list", nil, VulnListPage{}},
+		{"vuln/entry", nil, VulnEntryPage{}},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			tm := templates[c.name]
+			if tm == nil {
+				t.Fatalf("no template %q", c.name)
+			}
+			if c.subs == nil {
+				if err := templatecheck.CheckSafe(tm, c.typeval); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				for _, n := range c.subs {
+					s := tm.Lookup(n)
+					if s == nil {
+						t.Fatalf("no sub-template %q of %q", n, c.name)
 					}
-					if pkg.readmeContents != "" {
-						u.Readme = &internal.Readme{
-							Contents: pkg.readmeContents,
-							Filepath: pkg.readmeFilePath,
-						}
-					}
-					if pkg.docs != nil {
-						u.Documentation = pkg.docs
+					if err := templatecheck.CheckSafe(s, c.typeval); err != nil {
+						t.Fatalf("%s: %v", n, err)
 					}
 				}
-				if !mod.redistributable {
-					u.IsRedistributable = false
-					u.Licenses = nil
-					u.Documentation = nil
-					u.Readme = nil
-				}
 			}
-			postgres.MustInsertModule(ctx, t, testDB, m)
+		})
+	}
+}
+
+func TestStripScheme(t *testing.T) {
+	for _, test := range []struct {
+		url, want string
+	}{
+		{"http://github.com", "github.com"},
+		{"https://github.com/path/to/something", "github.com/path/to/something"},
+		{"example.com", "example.com"},
+		{"chrome-extension://abcd", "abcd"},
+		{"nonwellformed.com/path?://query=1", "query=1"},
+	} {
+		if got := stripScheme(test.url); got != test.want {
+			t.Errorf("%q: got %q, want %q", test.url, got, test.want)
 		}
 	}
 }
+
+func TestInstallFS(t *testing.T) {
+	s, handler, teardown := newTestServer(t, nil, nil)
+	defer teardown()
+	s.InstallFS("/dir", os.DirFS("."))
+	// Request this file.
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, httptest.NewRequest("GET", "/files/dir/frontend_test.go", nil))
+	if w.Code != http.StatusOK {
+		t.Errorf("got status code = %d, want %d", w.Code, http.StatusOK)
+	}
+	if want := "TestInstallFS"; !strings.Contains(w.Body.String(), want) {
+		t.Errorf("body does not contain %q", want)
+	}
+}
diff --git a/internal/frontend/imports.go b/internal/frontend/imports.go
index 19af68e..2f8f163 100644
--- a/internal/frontend/imports.go
+++ b/internal/frontend/imports.go
@@ -9,6 +9,7 @@
 	"strings"
 
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/serrors"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/text/language"
@@ -97,7 +98,7 @@
 	db, ok := ds.(internal.PostgresDB)
 	if !ok {
 		// The proxydatasource does not support the imported by page.
-		return nil, datasourceNotSupportedErr()
+		return nil, serrors.DatasourceNotSupportedError()
 	}
 
 	importedBy, err := db.GetImportedBy(ctx, pkgPath, modulePath, importedByLimit)
diff --git a/internal/frontend/latest_version.go b/internal/frontend/latest_version.go
index a98e61c..8af58fd 100644
--- a/internal/frontend/latest_version.go
+++ b/internal/frontend/latest_version.go
@@ -8,6 +8,7 @@
 	"context"
 
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/middleware/stats"
 )
@@ -31,7 +32,7 @@
 	if err != nil {
 		log.Errorf(ctx, "Server.GetLatestInfo: %v", err)
 	} else {
-		latest.MinorVersion = linkVersion(latest.MinorModulePath, latest.MinorVersion, latest.MinorVersion)
+		latest.MinorVersion = versions.LinkVersion(latest.MinorModulePath, latest.MinorVersion, latest.MinorVersion)
 	}
 	return latest
 }
diff --git a/internal/frontend/latest_version_test.go b/internal/frontend/latest_version_test.go
index 4382938..f3c9301 100644
--- a/internal/frontend/latest_version_test.go
+++ b/internal/frontend/latest_version_test.go
@@ -11,6 +11,7 @@
 
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/postgres"
+	"golang.org/x/pkgsite/internal/source"
 	"golang.org/x/pkgsite/internal/testing/sample"
 )
 
@@ -68,3 +69,47 @@
 		})
 	}
 }
+
+func insertTestModules(ctx context.Context, t *testing.T, mods []testModule) {
+	for _, mod := range mods {
+		var (
+			suffixes []string
+			pkgs     = make(map[string]testPackage)
+		)
+		for _, pkg := range mod.packages {
+			suffixes = append(suffixes, pkg.suffix)
+			pkgs[pkg.suffix] = pkg
+		}
+		for _, ver := range mod.versions {
+			m := sample.Module(mod.path, ver, suffixes...)
+			m.SourceInfo = source.NewGitHubInfo(sample.RepositoryURL, "", ver)
+			m.IsRedistributable = mod.redistributable
+			if !m.IsRedistributable {
+				m.Licenses = nil
+			}
+			for _, u := range m.Units {
+				if pkg, ok := pkgs[internal.Suffix(u.Path, m.ModulePath)]; ok {
+					if pkg.name != "" {
+						u.Name = pkg.name
+					}
+					if pkg.readmeContents != "" {
+						u.Readme = &internal.Readme{
+							Contents: pkg.readmeContents,
+							Filepath: pkg.readmeFilePath,
+						}
+					}
+					if pkg.docs != nil {
+						u.Documentation = pkg.docs
+					}
+				}
+				if !mod.redistributable {
+					u.IsRedistributable = false
+					u.Licenses = nil
+					u.Documentation = nil
+					u.Readme = nil
+				}
+			}
+			postgres.MustInsertModule(ctx, t, testDB, m)
+		}
+	}
+}
diff --git a/internal/frontend/main.go b/internal/frontend/main.go
index 5a0e519..32a4dc8 100644
--- a/internal/frontend/main.go
+++ b/internal/frontend/main.go
@@ -13,6 +13,7 @@
 	"golang.org/x/mod/semver"
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
+	"golang.org/x/pkgsite/internal/frontend/serrors"
 	"golang.org/x/pkgsite/internal/godoc"
 	"golang.org/x/pkgsite/internal/godoc/dochtml"
 	"golang.org/x/pkgsite/internal/log"
@@ -155,7 +156,7 @@
 				// Instead of returning a 500, return a 404 so the user can
 				// reprocess the documentation.
 				log.Errorf(ctx, "fetchMainDetails(%q, %q, %q): %v", um.Path, um.ModulePath, um.Version, err)
-				return nil, errUnitNotFoundWithoutFetch
+				return nil, serrors.ErrUnitNotFoundWithoutFetch
 			}
 			return nil, err
 		}
diff --git a/internal/frontend/search.go b/internal/frontend/search.go
index 1e031e0..2ef9680 100644
--- a/internal/frontend/search.go
+++ b/internal/frontend/search.go
@@ -23,6 +23,7 @@
 	"golang.org/x/pkgsite/internal/derrors"
 	pagepkg "golang.org/x/pkgsite/internal/frontend/page"
 	"golang.org/x/pkgsite/internal/frontend/serrors"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
@@ -66,7 +67,7 @@
 	searchSupport := ds.SearchSupport()
 	if searchSupport == internal.NoSearch {
 		// The proxydatasource does not support the imported by page.
-		return nil, datasourceNotSupportedErr()
+		return nil, serrors.DatasourceNotSupportedError()
 	}
 
 	ctx := r.Context()
@@ -308,7 +309,7 @@
 		Version:        r.Version,
 		ChipText:       chipText,
 		Synopsis:       r.Synopsis,
-		DisplayVersion: displayVersion(r.ModulePath, r.Version, r.Version),
+		DisplayVersion: versions.DisplayVersion(r.ModulePath, r.Version, r.Version),
 		Licenses:       r.Licenses,
 		CommitTime:     elapsedTime(r.CommitTime),
 		NumImportedBy:  pr.Sprint(r.NumImportedBy),
diff --git a/internal/frontend/serrors/serrors.go b/internal/frontend/serrors/serrors.go
index e2c08b9..b3c7cbd 100644
--- a/internal/frontend/serrors/serrors.go
+++ b/internal/frontend/serrors/serrors.go
@@ -9,6 +9,7 @@
 	"fmt"
 	"net/http"
 
+	"github.com/google/safehtml/template"
 	"golang.org/x/pkgsite/internal/frontend/page"
 )
 
@@ -27,3 +28,41 @@
 func (s *ServerError) Unwrap() error {
 	return s.Err
 }
+
+func DatasourceNotSupportedError() error {
+	return &ServerError{
+		Status: http.StatusFailedDependency,
+		Epage: &page.ErrorPage{
+			MessageTemplate: template.MakeTrustedTemplate(
+				`<h3 class="Error-message">This page is not supported by this datasource.</h3>`),
+		},
+	}
+}
+
+func InvalidVersionError(fullPath, requestedVersion string) error {
+	return &ServerError{
+		Status: http.StatusBadRequest,
+		Epage: &page.ErrorPage{
+			MessageTemplate: template.MakeTrustedTemplate(`
+					<h3 class="Error-message">{{.Version}} is not a valid semantic version.</h3>
+					<p class="Error-message">
+					  To search for packages like {{.Path}}, <a href="/search?q={{.Path}}">click here</a>.
+					</p>`),
+			MessageData: struct{ Path, Version string }{fullPath, requestedVersion},
+		},
+	}
+}
+
+// errUnitNotFoundWithoutFetch returns a 404 with instructions to the user on
+// how to manually fetch the package. No fetch button is provided. This is used
+// for very large modules or modules that previously 500ed.
+var ErrUnitNotFoundWithoutFetch = &ServerError{
+	Status: http.StatusNotFound,
+	Epage: &page.ErrorPage{
+		MessageTemplate: template.MakeTrustedTemplate(`
+					    <h3 class="Error-message">{{.StatusText}}</h3>
+					    <p class="Error-message">Check that you entered the URL correctly or try fetching it following the
+                        <a href="/about#adding-a-package">instructions here</a>.</p>`),
+		MessageData: struct{ StatusText string }{http.StatusText(http.StatusNotFound)},
+	},
+}
diff --git a/internal/frontend/tabs.go b/internal/frontend/tabs.go
index d7895dc..6e857bb 100644
--- a/internal/frontend/tabs.go
+++ b/internal/frontend/tabs.go
@@ -11,6 +11,7 @@
 
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/vuln"
 )
 
@@ -85,7 +86,7 @@
 		_, expandReadme := r.URL.Query()["readme"]
 		return fetchMainDetails(ctx, ds, um, requestedVersion, expandReadme, bc)
 	case tabVersions:
-		return fetchVersionsDetails(ctx, ds, um, vc)
+		return versions.FetchVersionsDetails(ctx, ds, um, vc)
 	case tabImports:
 		return fetchImportsDetails(ctx, ds, um.Path, um.ModulePath, um.Version)
 	case tabImportedBy:
diff --git a/internal/frontend/unit.go b/internal/frontend/unit.go
index c7e3eb5..16d4796 100644
--- a/internal/frontend/unit.go
+++ b/internal/frontend/unit.go
@@ -20,6 +20,7 @@
 	"golang.org/x/pkgsite/internal/frontend/page"
 	"golang.org/x/pkgsite/internal/frontend/serrors"
 	"golang.org/x/pkgsite/internal/frontend/urlinfo"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/stdlib"
@@ -129,7 +130,7 @@
 		}
 		db, ok := ds.(internal.PostgresDB)
 		if !ok || s.fetchServer == nil {
-			return datasourceNotSupportedErr()
+			return serrors.DatasourceNotSupportedError()
 		}
 		return s.fetchServer.ServePathNotFoundPage(w, r, db, info.FullPath, info.ModulePath, info.RequestedVersion)
 	}
@@ -207,18 +208,18 @@
 	if tabSettings.Name == "" {
 		basePage.UseResponsiveLayout = true
 	}
-	lv := linkVersion(um.ModulePath, info.RequestedVersion, um.Version)
+	lv := versions.LinkVersion(um.ModulePath, info.RequestedVersion, um.Version)
 	page := UnitPage{
 		BasePage:              basePage,
 		Unit:                  um,
 		Breadcrumb:            displayBreadcrumb(um, info.RequestedVersion),
 		Title:                 title,
 		SelectedTab:           tabSettings,
-		URLPath:               constructUnitURL(um.Path, um.ModulePath, info.RequestedVersion),
+		URLPath:               versions.ConstructUnitURL(um.Path, um.ModulePath, info.RequestedVersion),
 		CanonicalURLPath:      canonicalURLPath(um.Path, um.ModulePath, info.RequestedVersion, um.Version),
-		DisplayVersion:        displayVersion(um.ModulePath, info.RequestedVersion, um.Version),
+		DisplayVersion:        versions.DisplayVersion(um.ModulePath, info.RequestedVersion, um.Version),
 		LinkVersion:           lv,
-		LatestURL:             constructUnitURL(um.Path, um.ModulePath, version.Latest),
+		LatestURL:             versions.ConstructUnitURL(um.Path, um.ModulePath, version.Latest),
 		LatestMinorClass:      latestMinorClass(lv, latestInfo),
 		LatestMajorVersionURL: latestInfo.MajorUnitPath,
 		PageLabels:            pageLabels(um),
@@ -290,25 +291,11 @@
 	return true
 }
 
-// constructUnitURL returns a URL path that refers to the given unit at the requested
-// version. If requestedVersion is "latest", then the resulting path has no
-// version; otherwise, it has requestedVersion.
-func constructUnitURL(fullPath, modulePath, requestedVersion string) string {
-	if requestedVersion == version.Latest {
-		return "/" + fullPath
-	}
-	v := linkVersion(modulePath, requestedVersion, requestedVersion)
-	if fullPath == modulePath || modulePath == stdlib.ModulePath {
-		return fmt.Sprintf("/%s@%s", fullPath, v)
-	}
-	return fmt.Sprintf("/%s@%s/%s", modulePath, v, strings.TrimPrefix(fullPath, modulePath+"/"))
-}
-
 // canonicalURLPath constructs a URL path to the unit that always includes the
 // resolved version.
 func canonicalURLPath(fullPath, modulePath, requestedVersion, resolvedVersion string) string {
-	return constructUnitURL(fullPath, modulePath,
-		linkVersion(modulePath, requestedVersion, resolvedVersion))
+	return versions.ConstructUnitURL(fullPath, modulePath,
+		versions.LinkVersion(modulePath, requestedVersion, resolvedVersion))
 }
 
 func isGoProject(modulePath string) bool {
diff --git a/internal/frontend/unit_test.go b/internal/frontend/unit_test.go
index ae408cd..0f9db5e 100644
--- a/internal/frontend/unit_test.go
+++ b/internal/frontend/unit_test.go
@@ -8,6 +8,7 @@
 	"testing"
 
 	"golang.org/x/pkgsite/internal"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/testing/sample"
 )
 
@@ -36,7 +37,7 @@
 			"/math@go1.2.3",
 		},
 	} {
-		got := constructUnitURL(test.path, test.modpath, test.version)
+		got := versions.ConstructUnitURL(test.path, test.modpath, test.version)
 		if got != test.want {
 			t.Errorf("unitURLPath(%q, %q, %q) = %q, want %q", test.path, test.modpath, test.version, got, test.want)
 		}
diff --git a/internal/frontend/symbol.go b/internal/frontend/versions/symbol.go
similarity index 99%
rename from internal/frontend/symbol.go
rename to internal/frontend/versions/symbol.go
index 25952dd..828e925 100644
--- a/internal/frontend/symbol.go
+++ b/internal/frontend/versions/symbol.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package versions
 
 import (
 	"fmt"
diff --git a/internal/frontend/symbol_test.go b/internal/frontend/versions/symbol_test.go
similarity index 97%
rename from internal/frontend/symbol_test.go
rename to internal/frontend/versions/symbol_test.go
index c67c89f..0ce7236 100644
--- a/internal/frontend/symbol_test.go
+++ b/internal/frontend/versions/symbol_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package versions
 
 import (
 	"testing"
diff --git a/internal/frontend/versions.go b/internal/frontend/versions/versions.go
similarity index 88%
rename from internal/frontend/versions.go
rename to internal/frontend/versions/versions.go
index 74f0960..3d630b6 100644
--- a/internal/frontend/versions.go
+++ b/internal/frontend/versions/versions.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package versions
 
 import (
 	"context"
@@ -10,11 +10,13 @@
 	"path"
 	"sort"
 	"strings"
+	"time"
 	"unicode"
 
 	"golang.org/x/mod/semver"
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/fetch"
+	"golang.org/x/pkgsite/internal/frontend/serrors"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
@@ -85,11 +87,11 @@
 	Vulns               []vuln.Vuln
 }
 
-func fetchVersionsDetails(ctx context.Context, ds internal.DataSource, um *internal.UnitMeta, vc *vuln.Client) (*VersionsDetails, error) {
+func FetchVersionsDetails(ctx context.Context, ds internal.DataSource, um *internal.UnitMeta, vc *vuln.Client) (*VersionsDetails, error) {
 	db, ok := ds.(internal.PostgresDB)
 	if !ok {
 		// The proxydatasource does not support the imported by page.
-		return nil, datasourceNotSupportedErr()
+		return nil, serrors.DatasourceNotSupportedError()
 	}
 	versions, err := db.GetVersionsForPath(ctx, um.Path)
 	if err != nil {
@@ -112,7 +114,7 @@
 		} else {
 			versionPath = pathInVersion(internal.V1Path(um.Path, um.ModulePath), mi)
 		}
-		return constructUnitURL(versionPath, mi.ModulePath, linkVersion(mi.ModulePath, mi.Version, mi.Version))
+		return ConstructUnitURL(versionPath, mi.ModulePath, LinkVersion(mi.ModulePath, mi.Version, mi.Version))
 	}
 	return buildVersionDetails(ctx, um.ModulePath, um.Path, versions, sh, linkify, vc)
 }
@@ -188,7 +190,7 @@
 		vs := &VersionSummary{
 			Link:                linkify(mi),
 			CommitTime:          commitTime,
-			Version:             linkVersion(mi.ModulePath, mi.Version, mi.Version),
+			Version:             LinkVersion(mi.ModulePath, mi.Version, mi.Version),
 			IsMinor:             isMinor(mi.Version),
 			Retracted:           mi.Retracted,
 			RetractionRationale: shortRationale(mi.RetractionRationale),
@@ -369,8 +371,8 @@
 	return v[j+1:]
 }
 
-// displayVersion returns the version string, formatted for display.
-func displayVersion(modulePath, requestedVersion, resolvedVersion string) string {
+// DisplayVersion returns the version string, formatted for display.
+func DisplayVersion(modulePath, requestedVersion, resolvedVersion string) string {
 	if modulePath == stdlib.ModulePath && resolvedVersion != fetch.LocalVersion {
 		if stdlib.SupportedBranches[requestedVersion] ||
 			(strings.HasPrefix(resolvedVersion, "v0.0.0") && resolvedVersion != "v0.0.0") { // Plain v0.0.0 is from the go packages module getter
@@ -391,10 +393,10 @@
 	return formatVersion(resolvedVersion)
 }
 
-// linkVersion returns the version string, suitable for use in
+// LinkVersion returns the version string, suitable for use in
 // a link to this site.
 // See TestLinkVersion for examples.
-func linkVersion(modulePath, requestedVersion, resolvedVersion string) string {
+func LinkVersion(modulePath, requestedVersion, resolvedVersion string) string {
 	if modulePath == stdlib.ModulePath && resolvedVersion != fetch.LocalVersion {
 		if strings.HasPrefix(resolvedVersion, "go") {
 			return resolvedVersion // already a go version
@@ -419,3 +421,32 @@
 	}
 	return tag
 }
+
+// absoluteTime takes a date and returns a human-readable,
+// date with the format mmm d, yyyy.
+// TODO(matloob): This is a copy of internal/frontend.absoluteTime.
+// Unify it with that function again.
+func absoluteTime(date time.Time) string {
+	if date.IsZero() {
+		return "unknown"
+	}
+	// Convert to UTC because that is how the date is represented in the DB.
+	// (The pgx driver returns local times.) Example: if a date is stored
+	// as Jan 30 at midnight, then the local NYC time is on Jan 29, and this
+	// function would return "Jan 29" instead of the correct "Jan 30".
+	return date.In(time.UTC).Format("Jan _2, 2006")
+}
+
+// ConstructUnitURL returns a URL path that refers to the given unit at the requested
+// version. If requestedVersion is "latest", then the resulting path has no
+// version; otherwise, it has requestedVersion.
+func ConstructUnitURL(fullPath, modulePath, requestedVersion string) string {
+	if requestedVersion == version.Latest {
+		return "/" + fullPath
+	}
+	v := LinkVersion(modulePath, requestedVersion, requestedVersion)
+	if fullPath == modulePath || modulePath == stdlib.ModulePath {
+		return fmt.Sprintf("/%s@%s", fullPath, v)
+	}
+	return fmt.Sprintf("/%s@%s/%s", modulePath, v, strings.TrimPrefix(fullPath, modulePath+"/"))
+}
diff --git a/internal/frontend/versions_test.go b/internal/frontend/versions/versions_test.go
similarity index 95%
rename from internal/frontend/versions_test.go
rename to internal/frontend/versions/versions_test.go
index 31efad6..e779357 100644
--- a/internal/frontend/versions_test.go
+++ b/internal/frontend/versions/versions_test.go
@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package frontend
+package versions
 
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"golang.org/x/pkgsite/internal"
@@ -18,6 +19,14 @@
 	"golang.org/x/pkgsite/internal/vuln"
 )
 
+const testTimeout = 5 * time.Second
+
+var testDB *postgres.DB
+
+func TestMain(m *testing.M) {
+	postgres.RunDBTests("discovery_frontend_test", m, &testDB)
+}
+
 var (
 	modulePath1 = "test.com/module"
 	modulePath2 = "test.com/module/v2"
@@ -88,7 +97,7 @@
 		return &VersionList{
 			VersionListKey: VersionListKey{ModulePath: modulePath, Major: major, Incompatible: incompatible},
 			Versions: versionSummaries(pkgPath, versions, isStdlib, func(path, version string) string {
-				return constructUnitURL(pkgPath, modulePath, version)
+				return ConstructUnitURL(pkgPath, modulePath, version)
 			}),
 		}
 	}
@@ -225,9 +234,9 @@
 				postgres.MustInsertModule(ctx, t, testDB, v)
 			}
 
-			got, err := fetchVersionsDetails(ctx, testDB, &tc.pkg.UnitMeta, vc)
+			got, err := FetchVersionsDetails(ctx, testDB, &tc.pkg.UnitMeta, vc)
 			if err != nil {
-				t.Fatalf("fetchVersionsDetails(ctx, db, %q, %q): %v", tc.pkg.Path, tc.pkg.ModulePath, err)
+				t.Fatalf("FetchVersionsDetails(ctx, db, %q, %q): %v", tc.pkg.Path, tc.pkg.ModulePath, err)
 			}
 			for _, vl := range tc.wantDetails.ThisModule {
 				for _, v := range vl.Versions {
@@ -391,8 +400,8 @@
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			if got := displayVersion(test.fullPath, test.requestedVersion, test.resolvedVersion); got != test.want {
-				t.Errorf("displayVersion(%q, %q, %q) = %q, want %q",
+			if got := DisplayVersion(test.fullPath, test.requestedVersion, test.resolvedVersion); got != test.want {
+				t.Errorf("DisplayVersion(%q, %q, %q) = %q, want %q",
 					test.fullPath, test.requestedVersion, test.resolvedVersion, got, test.want)
 			}
 		})
@@ -465,8 +474,8 @@
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			if got := linkVersion(test.fullPath, test.requestedVersion, test.resolvedVersion); got != test.want {
-				t.Errorf("linkVersion(%q, %q, %q) = %q, want %q",
+			if got := LinkVersion(test.fullPath, test.requestedVersion, test.resolvedVersion); got != test.want {
+				t.Errorf("LinkVersion(%q, %q, %q) = %q, want %q",
 					test.fullPath, test.requestedVersion, test.resolvedVersion, got, test.want)
 			}
 		})
diff --git a/internal/frontend/vulns.go b/internal/frontend/vulns.go
index 93fe449..fa2b75f 100644
--- a/internal/frontend/vulns.go
+++ b/internal/frontend/vulns.go
@@ -43,7 +43,7 @@
 
 func (s *Server) serveVuln(w http.ResponseWriter, r *http.Request, _ internal.DataSource) error {
 	if s.vulnClient == nil {
-		return datasourceNotSupportedErr()
+		return serrors.DatasourceNotSupportedError()
 	}
 
 	vp, err := newVulnPage(r.Context(), r.URL, s.vulnClient)
diff --git a/internal/testing/integration/data_frontend_versions_test.go b/internal/testing/integration/data_frontend_versions_test.go
index b889c9d..7b3e2af 100644
--- a/internal/testing/integration/data_frontend_versions_test.go
+++ b/internal/testing/integration/data_frontend_versions_test.go
@@ -4,15 +4,17 @@
 
 package integration
 
-import "golang.org/x/pkgsite/internal/frontend"
+import (
+	"golang.org/x/pkgsite/internal/frontend/versions"
+)
 
-var versionsPageMultiGoosDuplicates = []*frontend.VersionList{
+var versionsPageMultiGoosDuplicates = []*versions.VersionList{
 	{
-		VersionListKey: frontend.VersionListKey{
+		VersionListKey: versions.VersionListKey{
 			ModulePath: "example.com/symbols",
 			Major:      "v1",
 		},
-		Versions: []*frontend.VersionSummary{
+		Versions: []*versions.VersionSummary{
 			{
 				CommitTime:          "Jan 30, 2019",
 				Link:                "/example.com/symbols@v1.2.0/duplicate",
@@ -20,7 +22,7 @@
 				RetractionRationale: "",
 				Version:             "v1.2.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "TokenType",
@@ -53,7 +55,7 @@
 							New:      true,
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "TokenShort",
 									Synopsis: "func TokenShort() TokenType",
@@ -75,7 +77,7 @@
 				RetractionRationale: "",
 				Version:             "v1.1.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "TokenShort",
@@ -93,13 +95,13 @@
 	},
 }
 
-var versionsPageMultiGoos = []*frontend.VersionList{
+var versionsPageMultiGoos = []*versions.VersionList{
 	{
-		VersionListKey: frontend.VersionListKey{
+		VersionListKey: versions.VersionListKey{
 			ModulePath: "example.com/symbols",
 			Major:      "v1",
 		},
-		Versions: []*frontend.VersionSummary{
+		Versions: []*versions.VersionSummary{
 			{
 				CommitTime:          "Jan 30, 2019",
 				Link:                "/example.com/symbols@v1.2.0/multigoos",
@@ -107,7 +109,7 @@
 				RetractionRationale: "",
 				Version:             "v1.2.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "CloseOnExec",
@@ -126,7 +128,7 @@
 							Section:  "Types",
 							Kind:     "Type",
 							Link:     "/example.com/symbols@v1.2.0/multigoos?GOOS=darwin#FD",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "FD.MyMethod",
 									Synopsis: "func (*FD) MyMethod()",
@@ -144,7 +146,7 @@
 							Section:  "Types",
 							Kind:     "Type",
 							Link:     "/example.com/symbols@v1.2.0/multigoos?GOOS=windows#FD",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "FD.MyWindowsMethod",
 									Synopsis: "func (*FD) MyWindowsMethod()",
@@ -166,7 +168,7 @@
 				RetractionRationale: "",
 				Version:             "v1.1.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "CloseOnExec",
@@ -204,13 +206,13 @@
 	},
 }
 
-var versionsPageHello = []*frontend.VersionList{
+var versionsPageHello = []*versions.VersionList{
 	{
-		VersionListKey: frontend.VersionListKey{
+		VersionListKey: versions.VersionListKey{
 			ModulePath: "example.com/symbols",
 			Major:      "v1",
 		},
-		Versions: []*frontend.VersionSummary{
+		Versions: []*versions.VersionSummary{
 			{
 				CommitTime:          "Jan 30, 2019",
 				Link:                "/example.com/symbols@v1.2.0/hello",
@@ -218,7 +220,7 @@
 				RetractionRationale: "",
 				Version:             "v1.2.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "Hello",
@@ -239,7 +241,7 @@
 				RetractionRationale: "",
 				Version:             "v1.1.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "Hello",
@@ -266,13 +268,13 @@
 	},
 }
 
-var versionsPageSymbols = []*frontend.VersionList{
+var versionsPageSymbols = []*versions.VersionList{
 	{
-		VersionListKey: frontend.VersionListKey{
+		VersionListKey: versions.VersionListKey{
 			ModulePath: "example.com/symbols",
 			Major:      "v1",
 		},
-		Versions: []*frontend.VersionSummary{
+		Versions: []*versions.VersionSummary{
 			{
 				CommitTime: "Jan 30, 2019",
 				Link:       "/example.com/symbols@v1.2.0",
@@ -284,7 +286,7 @@
 				Link:       "/example.com/symbols@v1.1.0",
 				Version:    "v1.1.0",
 				IsMinor:    true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "I2",
@@ -292,7 +294,7 @@
 							Link:     "/example.com/symbols@v1.1.0#I2",
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "I2.M2",
 									Synopsis: "M2 func()",
@@ -309,7 +311,7 @@
 							Link:     "/example.com/symbols@v1.1.0#S2",
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "S2.G",
 									Synopsis: "G int",
@@ -338,7 +340,7 @@
 				RetractionRationale: "",
 				Version:             "v1.0.0",
 				IsMinor:             true,
-				Symbols: [][]*frontend.Symbol{
+				Symbols: [][]*versions.Symbol{
 					{
 						{
 							Name:     "AA",
@@ -435,7 +437,7 @@
 							New:      true,
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "I1.M1",
 									Synopsis: "M1 func()",
@@ -469,7 +471,7 @@
 							New:      true,
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "DD",
 									Synopsis: "const DD",
@@ -503,7 +505,7 @@
 							New:      true,
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "S1.F",
 									Synopsis: "F int",
@@ -529,7 +531,7 @@
 							New:      true,
 							Section:  "Types",
 							Kind:     "Type",
-							Children: []*frontend.Symbol{
+							Children: []*versions.Symbol{
 								{
 									Name:     "CT",
 									Synopsis: "const CT",
diff --git a/internal/testing/integration/frontend_symbol_test.go b/internal/testing/integration/frontend_symbol_test.go
index acd2970..3080678 100644
--- a/internal/testing/integration/frontend_symbol_test.go
+++ b/internal/testing/integration/frontend_symbol_test.go
@@ -10,7 +10,7 @@
 	"fmt"
 	"testing"
 
-	"golang.org/x/pkgsite/internal/frontend"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/postgres"
 	"golang.org/x/pkgsite/internal/symbol"
 )
@@ -49,11 +49,11 @@
 			// Get frontend data.
 			urlPath := fmt.Sprintf("/%s?tab=versions&content=json", test.pkgPath)
 			body := getFrontendPage(t, urlPath)
-			var vd frontend.VersionsDetails
+			var vd versions.VersionsDetails
 			if err := json.Unmarshal([]byte(body), &vd); err != nil {
 				t.Fatalf("json.Unmarshal: %v\n %s", err, body)
 			}
-			sh, err := frontend.ParseVersionsDetails(&vd)
+			sh, err := versions.ParseVersionsDetails(&vd)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/internal/testing/integration/frontend_test.go b/internal/testing/integration/frontend_test.go
index 4e75204..4b66063 100644
--- a/internal/testing/integration/frontend_test.go
+++ b/internal/testing/integration/frontend_test.go
@@ -19,6 +19,7 @@
 	"golang.org/x/pkgsite/internal/experiment"
 	"golang.org/x/pkgsite/internal/fetch"
 	"golang.org/x/pkgsite/internal/frontend"
+	"golang.org/x/pkgsite/internal/frontend/fetchserver"
 	"golang.org/x/pkgsite/internal/middleware"
 	"golang.org/x/pkgsite/internal/postgres"
 	"golang.org/x/pkgsite/internal/proxy"
@@ -33,7 +34,7 @@
 func setupFrontend(ctx context.Context, t *testing.T, q queue.Queue, rc *redis.Client) *httptest.Server {
 	t.Helper()
 	const staticDir = "../../../static"
-	fs := &frontend.FetchServer{
+	fs := &fetchserver.FetchServer{
 		Queue:                q,
 		TaskIDChangeInterval: 10 * time.Minute,
 	}
@@ -90,7 +91,7 @@
 	sourceClient := source.NewClient(1 * time.Second)
 	q := queue.NewInMemory(cctx, 1, experimentNames,
 		func(ctx context.Context, mpath, version string) (_ int, err error) {
-			return frontend.FetchAndUpdateState(ctx, mpath, version, proxyClient, sourceClient, testDB)
+			return fetchserver.FetchAndUpdateState(ctx, mpath, version, proxyClient, sourceClient, testDB)
 		})
 	return q, func() {
 		cancel()
diff --git a/internal/testing/integration/frontend_versions_test.go b/internal/testing/integration/frontend_versions_test.go
index 2b9f369..ec03d9b 100644
--- a/internal/testing/integration/frontend_versions_test.go
+++ b/internal/testing/integration/frontend_versions_test.go
@@ -12,7 +12,7 @@
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	"golang.org/x/pkgsite/internal/frontend"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/postgres"
 )
 
@@ -24,7 +24,7 @@
 	const modulePath = "example.com/symbols"
 	for _, test := range []struct {
 		name, pkgPath string
-		want          []*frontend.VersionList
+		want          []*versions.VersionList
 	}{
 		{"versions page symbols - one version all symbols", modulePath, versionsPageSymbols},
 		{"versions page hello - multi GOOS", modulePath + "/hello", versionsPageHello},
@@ -35,11 +35,11 @@
 		t.Run(test.name, func(t *testing.T) {
 			urlPath := fmt.Sprintf("/%s?tab=versions&content=json", test.pkgPath)
 			body := getFrontendPage(t, urlPath)
-			var got frontend.VersionsDetails
+			var got versions.VersionsDetails
 			if err := json.Unmarshal([]byte(body), &got); err != nil {
 				t.Fatalf("json.Unmarshal: %v", err)
 			}
-			if diff := cmp.Diff(test.want, got.ThisModule, cmpopts.IgnoreUnexported(frontend.Symbol{})); diff != "" {
+			if diff := cmp.Diff(test.want, got.ThisModule, cmpopts.IgnoreUnexported(versions.Symbol{})); diff != "" {
 				t.Errorf("mismatch (-want, got):\n%s", diff)
 			}
 		})
diff --git a/tests/api/main.go b/tests/api/main.go
index 77040ac..111ad11 100755
--- a/tests/api/main.go
+++ b/tests/api/main.go
@@ -23,6 +23,7 @@
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/frontend"
+	"golang.org/x/pkgsite/internal/frontend/versions"
 	"golang.org/x/pkgsite/internal/proxy"
 	"golang.org/x/pkgsite/internal/symbol"
 	"golang.org/x/pkgsite/internal/version"
@@ -196,7 +197,7 @@
 		return err
 	}
 
-	sh, err := frontend.ParseVersionsDetails(vd)
+	sh, err := versions.ParseVersionsDetails(vd)
 	if err != nil {
 		return err
 	}