diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 19a57db9..2cd97d43 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -7,6 +7,21 @@ jobs:
     strategy:
       matrix:
         go: [1.14, 1.15]
+
+    services:
+      postgres:
+        image: postgres:13.0
+        env:
+          POSTGRES_USER: dcrpooluser
+          POSTGRES_PASSWORD: 12345
+          POSTGRES_DB: dcrpooltestdb
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
     steps:
       - name: Set up Go
         uses: actions/setup-go@v2
diff --git a/README.md b/README.md
index fd80d819..3cdf5d99 100644
--- a/README.md
+++ b/README.md
@@ -41,17 +41,13 @@ of the address mining rewards are paid to and its name, formatted as:
 the address provided in the username to create an account, all other connected 
 miners with the same address set will contribute work to that account.  
 
-As a contingency, the pool maintains a backup of the database (`backup.kv`), 
-created on shutdown in the same directory as the database itself.
-
 The user interface of the pool provides public access to statistics and pool 
 account data. Users of the pool can access all payments, mined blocks by the 
 account and also work contributed by clients of the account via the interface. 
 The interface is only accessible via HTTPS and by default uses a self-signed 
 certificate, served on port `:8080`. In production, particularly for pool 
 mining, a certificate from an authority (`CA`) like 
-[letsencrypt](https://letsencrypt.org/) is recommended. The user interface also 
-provides pool administrators database backup functionality when needed.
+[letsencrypt](https://letsencrypt.org/) is recommended.
 
 ## Installing and Updating
 
@@ -75,6 +71,17 @@ run `go install . ./cmd/...` in the root directory.  Some notes:
 - The `dcrpool` executable will be installed to `$GOPATH/bin`.  `GOPATH`
   defaults to `$HOME/go` (or `%USERPROFILE%\go` on Windows) if unset.
 
+## Database
+
+dcrpool can run with either a [Bolt database](https://github.com/etcd-io/bbolt)
+or a [Postgres database](https://www.postgresql.org/). Bolt is used by default.
+[postgres.md](./docs/postgres.md) has more details about running with Postgres.
+
+When running in Bolt mode, the pool maintains a backup of the database
+(`backup.kv`), created on shutdown in the same directory as the database itself.
+The user interface also provides functionality for pool administrators to backup
+Bolt database when necessary.
+
 ### Example of obtaining and building from source on Ubuntu
 
 ```sh
diff --git a/config.go b/config.go
index dad64787..2bfe7a22 100644
--- a/config.go
+++ b/config.go
@@ -58,6 +58,12 @@ const (
 	defaultMaxConnectionsPerHost = 100 // 100 connected clients per host
 	defaultWalletAccount         = 0
 	defaultCoinbaseConfTimeout   = time.Minute * 5 // one block time
+	defaultUsePostgres           = false
+	defaultPGHost                = "127.0.0.1"
+	defaultPGPort                = 5432
+	defaultPGUser                = "dcrpooluser"
+	defaultPGPass                = "12345"
+	defaultPGDBName              = "dcrpooldb"
 )
 
 var (
@@ -128,6 +134,12 @@ type config struct {
 	DCR1Port              uint32        `long:"dcr1port" ini-name:"dcr1port" description:"Obelisk DCR1 connection port."`
 	CoinbaseConfTimeout   time.Duration `long:"conftimeout" ini-name:"conftimeout" description:"The duration to wait for coinbase confirmations."`
 	GenCertsOnly          bool          `long:"gencertsonly" ini-name:"gencertsonly" description:"Only generate needed TLS key pairs and terminate."`
+	UsePostgres           bool          `long:"postgres" ini-name:"postgres" description:"Use postgres database instead of bolt."`
+	PGHost                string        `long:"postgreshost" ini-name:"postgreshost" description:"Host to establish a postgres connection."`
+	PGPort                uint32        `long:"postgresport" ini-name:"postgresport" description:"Port to establish a postgres connection."`
+	PGUser                string        `long:"postgresuser" ini-name:"postgresuser" description:"Username for postgres authentication."`
+	PGPass                string        `long:"postgrespass" ini-name:"postgrespass" description:"Password for postgres authentication."`
+	PGDBName              string        `long:"postgresdbname" ini-name:"postgresdbname" description:"Postgres database name."`
 	poolFeeAddrs          []dcrutil.Address
 	dcrdRPCCerts          []byte
 	net                   *params
@@ -362,6 +374,12 @@ func loadConfig() (*config, []string, error) {
 		DCR1Port:              defaultDCR1Port,
 		WalletAccount:         defaultWalletAccount,
 		CoinbaseConfTimeout:   defaultCoinbaseConfTimeout,
+		UsePostgres:           defaultUsePostgres,
+		PGHost:                defaultPGHost,
+		PGPort:                defaultPGPort,
+		PGUser:                defaultPGUser,
+		PGPass:                defaultPGPass,
+		PGDBName:              defaultPGDBName,
 	}
 
 	// Service options which are only added on Windows.
diff --git a/dcrpool.go b/dcrpool.go
index b6d94835..30c6c10c 100644
--- a/dcrpool.go
+++ b/dcrpool.go
@@ -212,13 +212,17 @@ func newPool(db pool.Database, cfg *config) (*miningPool, error) {
 		FetchLastPaymentInfo:  p.hub.FetchLastPaymentInfo,
 		FetchMinedWork:        p.hub.FetchMinedWork,
 		FetchWorkQuotas:       p.hub.FetchWorkQuotas,
-		HTTPBackupDB:          p.hub.HTTPBackupDB,
 		FetchClients:          p.hub.FetchClients,
 		AccountExists:         p.hub.AccountExists,
 		FetchArchivedPayments: p.hub.FetchArchivedPayments,
 		FetchPendingPayments:  p.hub.FetchPendingPayments,
 		FetchCacheChannel:     p.hub.FetchCacheChannel,
 	}
+
+	if !cfg.UsePostgres {
+		gcfg.HTTPBackupDB = p.hub.HTTPBackupDB
+	}
+
 	p.gui, err = gui.NewGUI(gcfg)
 	if err != nil {
 		p.hub.CloseListeners()
@@ -245,7 +249,14 @@ func main() {
 		}
 	}()
 
-	db, err := pool.InitBoltDB(cfg.DBFile)
+	var db pool.Database
+	if cfg.UsePostgres {
+		db, err = pool.InitPostgresDB(cfg.PGHost, cfg.PGPort, cfg.PGUser,
+			cfg.PGPass, cfg.PGDBName)
+	} else {
+		db, err = pool.InitBoltDB(cfg.DBFile)
+	}
+
 	if err != nil {
 		mpLog.Errorf("failed to initialize database: %v", err)
 		os.Exit(1)
@@ -292,11 +303,13 @@ func main() {
 	p.hub.Run(p.ctx)
 
 	// hub.Run() blocks until the pool is fully shut down. When it returns,
-	// write a backup of the DB, and then close the DB.
-	mpLog.Tracef("Backing up database.")
-	err = db.Backup(pool.BoltBackupFile)
-	if err != nil {
-		mpLog.Errorf("failed to write database backup file: %v", err)
+	// write a backup of the DB (if not using postgres), and then close the DB.
+	if !cfg.UsePostgres {
+		mpLog.Tracef("Backing up database.")
+		err = db.Backup(pool.BoltBackupFile)
+		if err != nil {
+			mpLog.Errorf("failed to write database backup file: %v", err)
+		}
 	}
 
 	db.Close()
diff --git a/docs/postgres.md b/docs/postgres.md
new file mode 100644
index 00000000..343e62c6
--- /dev/null
+++ b/docs/postgres.md
@@ -0,0 +1,49 @@
+# Running dcrpool with PostgreSQL
+
+Tested with PostgreSQL 13.0.
+
+**Note:** When running in Postgres mode, backups will not be created
+automatically by dcrpool.
+
+## Setup
+
+1. Connect to your instance of PostgreSQL using `psql` to create a new database
+    and a new user for dcrpool.
+    Be sure to substitute the example password `12345` with something more secure.
+
+    ```no-highlight
+    postgres=# CREATE DATABASE dcrpooldb;
+    CREATE DATABASE
+    postgres=# CREATE USER dcrpooluser WITH ENCRYPTED PASSWORD '12345';
+    CREATE ROLE
+    postgres=# GRANT ALL PRIVILEGES ON DATABASE dcrpooldb to dcrpooluser;
+    GRANT
+    ```
+
+1. **Developers only** - if you are modifying code and wish to run the dcrpool
+   test suite, you will need to create an additional database.
+
+    ```no-highlight
+    postgres=# CREATE DATABASE dcrpooltestdb;
+    CREATE DATABASE
+    postgres=# GRANT ALL PRIVILEGES ON DATABASE dcrpooltestdb to dcrpooluser;
+    GRANT
+    ```
+
+1. Add the database connection details to the dcrpool config file.
+
+    ```no-highlight
+    postgres=true
+    postgreshost=127.0.0.1
+    postgresport=5432
+    postgresuser=dcrpooluser
+    postgrespass=12345
+    postgresdbname=dcrpooldb
+    ```
+
+## Tuning
+
+A helpful online tool to determine good settings for your system is called
+[PGTune](https://pgtune.leopard.in.ua/#/). After providing basic information
+about your hardware, PGTune will output a snippet of optimization settings to
+add to your PostgreSQL config.
diff --git a/go.mod b/go.mod
index 8cf2be12..c2951b6b 100644
--- a/go.mod
+++ b/go.mod
@@ -22,6 +22,7 @@ require (
 	github.com/jessevdk/go-flags v1.4.1-0.20200711081900-c17162fe8fd7
 	github.com/jrick/logrotate v1.0.0
 	github.com/kr/pretty v0.1.0 // indirect
+	github.com/lib/pq v1.8.0
 	go.etcd.io/bbolt v1.3.5
 	golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a
 	golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1
diff --git a/go.sum b/go.sum
index e194e323..d17410fc 100644
--- a/go.sum
+++ b/go.sum
@@ -115,6 +115,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lib/pq v1.8.0 h1:9xohqzkUwzR4Ga4ivdTcawVS89YSDVxXMa3xJX3cGzg=
+github.com/lib/pq v1.8.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
diff --git a/gui/admin.go b/gui/admin.go
index 8e8f80f2..0c9b8efc 100644
--- a/gui/admin.go
+++ b/gui/admin.go
@@ -22,6 +22,7 @@ type adminPageData struct {
 	ArchivedPayments      []*archivedPayment
 	PendingPaymentsTotal  string
 	PendingPayments       []*pendingPayment
+	BackupAvailable       bool
 }
 
 // adminPage is the handler for "GET /admin". If the current session is
@@ -73,6 +74,7 @@ func (ui *GUI) adminPage(w http.ResponseWriter, r *http.Request) {
 		PendingPayments:       pendingPmts,
 		ArchivedPaymentsTotal: totalArchived,
 		ArchivedPayments:      archivedPmts,
+		BackupAvailable:       ui.cfg.HTTPBackupDB != nil,
 	}
 
 	ui.renderTemplate(w, "admin", pageData)
diff --git a/gui/assets/templates/admin.html b/gui/assets/templates/admin.html
index 53e90f6b..e57ee1a6 100644
--- a/gui/assets/templates/admin.html
+++ b/gui/assets/templates/admin.html
@@ -9,11 +9,12 @@
             <h1 class="mr-auto text-nowrap">Admin Panel</h1>
             
             <div class="row mr-1">
+                {{ if .BackupAvailable }}
                 <form class="p-2" action="/backup" method="post">
                     {{.HeaderData.CSRF}}
                     <button type="submit" class="btn btn-primary btn-small">Backup</button>
                 </form>
-                
+                {{ end }}
                 <form class="p-2" action="/logout" method="post">
                     {{.HeaderData.CSRF}}
                     <button type="submit" class="btn btn-primary btn-small">Logout</button>
diff --git a/harness.sh b/harness.sh
index ea3f5ff1..b94d520d 100755
--- a/harness.sh
+++ b/harness.sh
@@ -29,6 +29,15 @@ MINER_MAX_PROCS=1
 PAYMENT_METHOD="pplns"
 LAST_N_PERIOD=5m
 GUI_DIR="${HARNESS_ROOT}/gui"
+
+# Using postgres requires the DB specified below to exist and contain no data.
+USE_POSTGRES=true
+POSTGRES_HOST=127.0.0.1
+POSTGRES_PORT=5432
+POSTGRES_USER=dcrpooluser
+POSTGRES_PASS=12345
+POSTGRES_DBNAME=dcrpooldb
+
 # CPU_MINING_ADDR is the mining address printed during creation of vwallet.
 # Initial block rewards from `generate` are sent here so vwallet can buy tickets.
 CPU_MINING_ADDR="SsaJxXSymEGroxAiUY9u1mRq1DDWLxn5WhB"
@@ -128,6 +137,12 @@ adminpass=${ADMIN_PASS}
 guidir=${GUI_DIR}
 designation=${TMUX_SESSION}
 profile=6060
+postgres=${USE_POSTGRES}
+postgreshost=${POSTGRES_HOST}
+postgresport=${POSTGRES_PORT}
+postgresuser=${POSTGRES_USER}
+postgrespass=${POSTGRES_PASS}
+postgresdbname=${POSTGRES_DBNAME}
 EOF
 
 cat > "${HARNESS_ROOT}/mwallet/dcrmwctl.conf" <<EOF
diff --git a/pool/acceptedwork.go b/pool/acceptedwork.go
index e3405719..8c22f99d 100644
--- a/pool/acceptedwork.go
+++ b/pool/acceptedwork.go
@@ -61,6 +61,7 @@ func NewAcceptedWork(blockHash string, prevHash string, height uint32,
 }
 
 // fetchAcceptedWork fetches the accepted work referenced by the provided id.
+// Returns an error if the work is not found.
 func (db *BoltDB) fetchAcceptedWork(id string) (*AcceptedWork, error) {
 	const funcName = "fetchAcceptedWork"
 	var work AcceptedWork
@@ -122,7 +123,8 @@ func (db *BoltDB) persistAcceptedWork(work *AcceptedWork) error {
 	})
 }
 
-// updateAcceptedWork persists modifications to an existing work.
+// updateAcceptedWork persists modifications to an existing work. Returns an
+// error if the work is not found.
 func (db *BoltDB) updateAcceptedWork(work *AcceptedWork) error {
 	const funcName = "updateAcceptedWork"
 	return db.DB.Update(func(tx *bolt.Tx) error {
diff --git a/pool/boltdb.go b/pool/boltdb.go
index 49062c28..84d46bcf 100644
--- a/pool/boltdb.go
+++ b/pool/boltdb.go
@@ -228,11 +228,9 @@ func nanoToBigEndianBytes(nano int64) []byte {
 	return b
 }
 
+// fetchPoolMode retrives the pool mode from the database. PoolMode is stored as
+// a uint32 for historical reasons. 0 indicates Public, 1 indicates Solo.
 func (db *BoltDB) fetchPoolMode() (uint32, error) {
-	// PoolMode is stored as a uint32 for historical reasons.
-	// 0 indicates Public
-	// 1 indicates Solo
-
 	var mode uint32
 	err := db.DB.View(func(tx *bolt.Tx) error {
 		pbkt, err := fetchPoolBucket(tx)
@@ -253,10 +251,10 @@ func (db *BoltDB) fetchPoolMode() (uint32, error) {
 	return mode, nil
 }
 
+// persistPoolMode stores the pool mode in the database. PoolMode is stored as a
+// uint32 for historical reasons. 0 indicates Public, 1 indicates Solo.
 func (db *BoltDB) persistPoolMode(mode uint32) error {
-	// PoolMode is stored as a uint32 for historical reasons.
-	// 0 indicates Public
-	// 1 indicates Solo
+
 	return db.DB.Update(func(tx *bolt.Tx) error {
 		pbkt := tx.Bucket(poolBkt)
 		b := make([]byte, 4)
@@ -265,6 +263,7 @@ func (db *BoltDB) persistPoolMode(mode uint32) error {
 	})
 }
 
+// fetchCSRFSecret retrieves the bytes used for the CSRF secret from the database.
 func (db *BoltDB) fetchCSRFSecret() ([]byte, error) {
 	var secret []byte
 
@@ -293,6 +292,7 @@ func (db *BoltDB) fetchCSRFSecret() ([]byte, error) {
 	return secret, nil
 }
 
+// persistCSRFSecret stores the bytes used for the CSRF secret in the database.
 func (db *BoltDB) persistCSRFSecret(secret []byte) error {
 	return db.DB.Update(func(tx *bolt.Tx) error {
 		pbkt := tx.Bucket(poolBkt)
@@ -305,6 +305,8 @@ func (db *BoltDB) persistCSRFSecret(secret []byte) error {
 	})
 }
 
+// persistLastPaymentInfo stores the last payment height and paidOn timestamp
+// in the database.
 func (db *BoltDB) persistLastPaymentInfo(height uint32, paidOn int64) error {
 	funcName := "persistLastPaymentInfo"
 	return db.DB.Update(func(tx *bolt.Tx) error {
@@ -333,6 +335,8 @@ func (db *BoltDB) persistLastPaymentInfo(height uint32, paidOn int64) error {
 	})
 }
 
+// loadLastPaymentInfo retrieves the last payment height and paidOn timestamp
+// from the database.
 func (db *BoltDB) loadLastPaymentInfo() (uint32, int64, error) {
 	funcName := "loadLastPaymentInfo"
 	var height uint32
@@ -364,6 +368,8 @@ func (db *BoltDB) loadLastPaymentInfo() (uint32, int64, error) {
 	return height, paidOn, nil
 }
 
+// persistLastPaymentCreatedOn stores the last payment createdOn timestamp in
+// the database.
 func (db *BoltDB) persistLastPaymentCreatedOn(createdOn int64) error {
 	funcName := "persistLastPaymentCreatedOn"
 	return db.DB.Update(func(tx *bolt.Tx) error {
@@ -381,6 +387,8 @@ func (db *BoltDB) persistLastPaymentCreatedOn(createdOn int64) error {
 	})
 }
 
+// loadLastPaymentCreatedOn retrieves the last payment createdOn timestamp from
+// the database.
 func (db *BoltDB) loadLastPaymentCreatedOn() (int64, error) {
 	funcName := "loadLastPaymentCreatedOn"
 	var createdOn int64
@@ -406,10 +414,13 @@ func (db *BoltDB) loadLastPaymentCreatedOn() (int64, error) {
 	return createdOn, nil
 }
 
+// Close closes the Bolt database.
 func (db *BoltDB) Close() error {
 	return db.DB.Close()
 }
 
+// httpBackup streams a backup of the entire database over the provided HTTP
+// response writer.
 func (db *BoltDB) httpBackup(w http.ResponseWriter) error {
 	err := db.DB.View(func(tx *bolt.Tx) error {
 		w.Header().Set("Content-Type", "application/octet-stream")
diff --git a/pool/database.go b/pool/database.go
index 0da18503..20869417 100644
--- a/pool/database.go
+++ b/pool/database.go
@@ -1,6 +1,7 @@
 package pool
 
 import (
+	"database/sql"
 	"net/http"
 
 	bolt "go.etcd.io/bbolt"
@@ -67,3 +68,8 @@ type Database interface {
 type BoltDB struct {
 	DB *bolt.DB
 }
+
+// PostgresDB is a wrapper around sql.DB which implements the Database interface.
+type PostgresDB struct {
+	DB *sql.DB
+}
diff --git a/pool/db_test.go b/pool/db_test.go
index 0a3db7b8..ff9e76da 100644
--- a/pool/db_test.go
+++ b/pool/db_test.go
@@ -231,23 +231,23 @@ func testLastPaymentCreatedOn(t *testing.T) {
 	// Expect an error if no value set.
 	_, err := db.loadLastPaymentCreatedOn()
 	if !errors.Is(err, ErrValueNotFound) {
-		t.Fatalf("[loadLastPaymentCreatedOn] expected value not found error, got: %v", err)
+		t.Fatalf("expected value not found error, got: %v", err)
 	}
 
 	// Set some values.
 	lastPaymentCreatedOn := time.Now().UnixNano()
 	err = db.persistLastPaymentCreatedOn(lastPaymentCreatedOn)
 	if err != nil {
-		t.Fatalf("[persistLastPaymentCreatedOn] unable to persist last payment created on: %v", err)
+		t.Fatalf("unable to persist last payment created on: %v", err)
 	}
 
 	// Ensure values can be retrieved.
 	paymentCreatedOn, err := db.loadLastPaymentCreatedOn()
 	if err != nil {
-		t.Fatalf("[loadLastPaymentCreatedOn] unable to load last payment created on: %v", err)
+		t.Fatalf("unable to load last payment created on: %v", err)
 	}
 	if lastPaymentCreatedOn != paymentCreatedOn {
-		t.Fatalf("[loadLastPaymentCreatedOn] expected last payment created on to be %d, got %d",
+		t.Fatalf("expected last payment created on to be %d, got %d",
 			lastPaymentCreatedOn, paymentCreatedOn)
 	}
 }
@@ -294,7 +294,7 @@ func testLastPaymentInfo(t *testing.T) {
 	// Expect an error if no value set.
 	_, _, err := db.loadLastPaymentInfo()
 	if !errors.Is(err, ErrValueNotFound) {
-		t.Fatalf("[loadLastPaymentInfo] expected value not found error, got: %v", err)
+		t.Fatalf("expected value not found error, got: %v", err)
 	}
 
 	// Set some values.
@@ -302,22 +302,22 @@ func testLastPaymentInfo(t *testing.T) {
 	lastPaymentPaidOn := time.Now().UnixNano()
 	err = db.persistLastPaymentInfo(lastPaymentHeight, lastPaymentPaidOn)
 	if err != nil {
-		t.Fatalf("[persistLastPaymentInfo] unable to persist last payment info: %v", err)
+		t.Fatalf("unable to persist last payment info: %v", err)
 	}
 
 	// Ensure values can be retrieved.
 	paymentHeight, paymentPaidOn, err := db.loadLastPaymentInfo()
 	if err != nil {
-		t.Fatalf("[loadLastPaymentInfo] unable to load last payment info: %v", err)
+		t.Fatalf("unable to load last payment info: %v", err)
 	}
 
 	if lastPaymentHeight != paymentHeight {
-		t.Fatalf("[loadLastPaymentInfo] expected last payment height to be %d, got %d",
+		t.Fatalf("expected last payment height to be %d, got %d",
 			paymentHeight, paymentHeight)
 	}
 
 	if lastPaymentPaidOn != paymentPaidOn {
-		t.Fatalf("[loadLastPaymentInfo] expected last payment paid on to be %d, got %d",
+		t.Fatalf("expected last payment paid on to be %d, got %d",
 			lastPaymentPaidOn, paymentPaidOn)
 	}
 }
diff --git a/pool/pool_test.go b/pool/pool_test.go
index 90f4fca4..7002136d 100644
--- a/pool/pool_test.go
+++ b/pool/pool_test.go
@@ -24,28 +24,54 @@ var (
 		"SsnbEmxCVXskgTHXvf3rEa17NA39qQuGHwQ",
 		chaincfg.SimNetParams())
 
-	db *BoltDB
+	db Database
 )
 
-// setupDB initializes the pool database.
-func setupDB() error {
+func setupPostgresDB() (*PostgresDB, error) {
+	pgHost := "127.0.0.1"
+	pgPort := uint32(5432)
+	pgUser := "dcrpooluser"
+	pgPass := "12345"
+	pgDBName := "dcrpooltestdb"
+	return InitPostgresDB(pgHost, pgPort, pgUser, pgPass, pgDBName)
+}
+
+func teardownPostgresDB(db *PostgresDB) error {
+	const stmt = `
+		DROP TABLE IF EXISTS accounts;
+		DROP TABLE IF EXISTS jobs;
+		DROP TABLE IF EXISTS shares;
+		DROP TABLE IF EXISTS payments;
+		DROP TABLE IF EXISTS archivedpayments;
+		DROP TABLE IF EXISTS acceptedwork;
+		DROP TABLE IF EXISTS metadata;
+	`
+	_, err := db.DB.Exec(stmt)
+	if err != nil {
+		return err
+	}
+	return db.Close()
+}
+
+// setupBoltDB initializes a bolt database.
+func setupBoltDB() (*BoltDB, error) {
 	os.Remove(testDB)
 	var err error
-	db, err = openBoltDB(testDB)
+	db, err := openBoltDB(testDB)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	err = createBuckets(db)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	err = upgradeDB(db)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	return err
+	return db, err
 }
 
 // teardownBoltDB closes the connection to the db and deletes the db file.
@@ -58,11 +84,10 @@ func teardownBoltDB(db *BoltDB, dbPath string) error {
 }
 
 // TestPool runs all pool related tests which require a real database.
-// An clean instance of bbolt is created and initialized with buckets before
-// each test.
 func TestPool(t *testing.T) {
 
-	// All sub-tests to run.
+	// All sub-tests to run. All of these tests will be run with a postgres
+	// database and a bolt database.
 	tests := map[string]func(*testing.T){
 		"testCSRFSecret":             testCSRFSecret,
 		"testLastPaymentInfo":        testLastPaymentInfo,
@@ -89,21 +114,37 @@ func TestPool(t *testing.T) {
 		"testHub":                    testHub,
 	}
 
+	// Run all tests with bolt DB.
 	for testName, test := range tests {
-		// Create a new blank database for each sub-test.
-		var err error
-		err = setupDB()
+		boltDB, err := setupBoltDB()
 		if err != nil {
-			t.Fatalf("setup error: %v", err)
+			t.Fatalf("setupBoltDB error: %v", err)
 		}
 
-		// Run the sub-test.
-		t.Run(testName, test)
+		db = boltDB
+
+		t.Run(testName+"_Bolt", test)
+
+		err = teardownBoltDB(boltDB, testDB)
+		if err != nil {
+			t.Fatalf("bolt teardown error: %v", err)
+		}
+	}
+
+	// Run all tests with postgres DB.
+	for testName, test := range tests {
+		postgresDB, err := setupPostgresDB()
+		if err != nil {
+			t.Fatalf("setupPostgresDB error: %v", err)
+		}
+
+		db = postgresDB
+
+		t.Run(testName+"_Postgres", test)
 
-		// Remove database.
-		err = teardownBoltDB(db, testDB)
+		err = teardownPostgresDB(postgresDB)
 		if err != nil {
-			t.Fatalf("teardown error: %v", err)
+			t.Fatalf("postgres teardown error: %v", err)
 		}
 	}
 
diff --git a/pool/postgres.go b/pool/postgres.go
new file mode 100644
index 00000000..e5e276f0
--- /dev/null
+++ b/pool/postgres.go
@@ -0,0 +1,754 @@
+// Copyright (c) 2020 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package pool
+
+import (
+	"database/sql"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math/big"
+	"net/http"
+	"time"
+
+	"github.com/decred/dcrd/dcrutil/v3"
+
+	"github.com/lib/pq"
+)
+
+// InitPostgresDB connects to the specified database and creates all tables
+// required by dcrpool.
+func InitPostgresDB(host string, port uint32, user, pass, dbName string) (*PostgresDB, error) {
+	const funcName = "InitPostgresDB"
+
+	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
+		"password=%s dbname=%s sslmode=disable",
+		host, port, user, pass, dbName)
+
+	db, err := sql.Open("postgres", psqlInfo)
+	if err != nil {
+		desc := fmt.Sprintf("%s: unable to open postgres: %v", funcName, err)
+		return nil, dbError(ErrDBOpen, desc)
+	}
+
+	// Send a Ping() to validate the db connection. This is because the Open()
+	// func does not actually create a connection to the database, it just
+	// validates the provided arguments.
+	err = db.Ping()
+	if err != nil {
+		desc := fmt.Sprintf("%s: unable to connect to postgres: %v", funcName, err)
+		return nil, dbError(ErrDBOpen, desc)
+	}
+
+	// Create all of the tables required by dcrpool.
+	_, err = db.Exec(createTableMetadata)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTableAccounts)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTablePayments)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTableArchivedPayments)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTableJobs)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTableShares)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Exec(createTableAcceptedWork)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PostgresDB{db}, nil
+}
+
+// Close closes the postgres database connection.
+func (db *PostgresDB) Close() error {
+	return db.DB.Close()
+}
+
+// decodePaymentRows deserializes the provided SQL rows into a slice of Payment
+// structs.
+func decodePaymentRows(rows *sql.Rows) ([]*Payment, error) {
+	var toReturn []*Payment
+	for rows.Next() {
+		var uuid, account, transactionID, sourceBlockHash, sourceCoinbase string
+		var estimatedMaturity, height, paidOnHeight uint32
+		var amount, createdon int64
+		err := rows.Scan(&uuid, &account, &estimatedMaturity,
+			&height, &amount, &createdon, &paidOnHeight, &transactionID,
+			&sourceBlockHash, &sourceCoinbase)
+		if err != nil {
+			return nil, err
+		}
+
+		payment := &Payment{uuid, account, estimatedMaturity,
+			height, dcrutil.Amount(amount), createdon, paidOnHeight, transactionID,
+			&PaymentSource{sourceBlockHash, sourceCoinbase}}
+		toReturn = append(toReturn, payment)
+	}
+
+	err := rows.Err()
+	if err != nil {
+		return nil, err
+	}
+
+	return toReturn, nil
+}
+
+// decodeWorkRows deserializes the provided SQL rows into a slice of
+// AcceptedWork structs.
+func decodeWorkRows(rows *sql.Rows) ([]*AcceptedWork, error) {
+	var toReturn []*AcceptedWork
+	for rows.Next() {
+		var uuid, blockhash, prevhash, minedby, miner string
+		var confirmed bool
+		var height uint32
+		var createdOn int64
+		err := rows.Scan(&uuid, &blockhash, &prevhash, &height,
+			&minedby, &miner, &createdOn, &confirmed)
+		if err != nil {
+			return nil, err
+		}
+
+		work := &AcceptedWork{uuid, blockhash, prevhash, height,
+			minedby, miner, createdOn, confirmed}
+		toReturn = append(toReturn, work)
+	}
+
+	err := rows.Err()
+	if err != nil {
+		return nil, err
+	}
+
+	return toReturn, nil
+}
+
+// decodeShareRows deserializes the provided SQL rows into a slice of Share
+// structs.
+func decodeShareRows(rows *sql.Rows) ([]*Share, error) {
+	var toReturn []*Share
+	for rows.Next() {
+		var uuid, account, weight string
+		var createdon int64
+		err := rows.Scan(&uuid, &account, &weight, &createdon)
+		if err != nil {
+			return nil, err
+		}
+
+		weightRat, ok := new(big.Rat).SetString(weight)
+		if !ok {
+			desc := fmt.Sprintf("unable to decode rat string: %v", err)
+			return nil, dbError(ErrParse, desc)
+		}
+		share := &Share{uuid, account, weightRat, createdon}
+		toReturn = append(toReturn, share)
+	}
+
+	err := rows.Err()
+	if err != nil {
+		return nil, err
+	}
+
+	return toReturn, nil
+}
+
+// httpBackup is not implemented for postgres database.
+func (db *PostgresDB) httpBackup(w http.ResponseWriter) error {
+	return errors.New("httpBackup is not implemented for postgres database")
+}
+
+// Backup is not implemented for postgres database.
+func (db *PostgresDB) Backup(fileName string) error {
+	return errors.New("Backup is not implemented for postgres database")
+}
+
+// fetchPoolMode retrives the pool mode from the database. PoolMode is stored as
+// a uint32 for historical reasons. 0 indicates Public, 1 indicates Solo.
+func (db *PostgresDB) fetchPoolMode() (uint32, error) {
+	const funcName = "fetchPoolMode"
+	var poolmode uint32
+	err := db.DB.QueryRow(selectPoolMode).Scan(&poolmode)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no value found for poolmode", funcName)
+			return 0, dbError(ErrValueNotFound, desc)
+		}
+
+		return 0, err
+	}
+	return poolmode, nil
+}
+
+// persistPoolMode stores the pool mode in the database. PoolMode is stored as a
+// uint32 for historical reasons. 0 indicates Public, 1 indicates Solo.
+func (db *PostgresDB) persistPoolMode(mode uint32) error {
+	_, err := db.DB.Exec(insertPoolMode, mode)
+	return err
+}
+
+// fetchCSRFSecret retrieves the bytes used for the CSRF secret from the database.
+func (db *PostgresDB) fetchCSRFSecret() ([]byte, error) {
+	const funcName = "fetchCSRFSecret"
+	var secret string
+	err := db.DB.QueryRow(selectCSRFSecret).Scan(&secret)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no value found for csrfsecret", funcName)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+
+	decoded, err := hex.DecodeString(secret)
+	if err != nil {
+		desc := fmt.Sprintf("%s: unable to decode csrf secret: %v",
+			funcName, err)
+		return nil, dbError(ErrParse, desc)
+	}
+
+	return decoded, nil
+}
+
+// persistCSRFSecret stores the bytes used for the CSRF secret in the database.
+func (db *PostgresDB) persistCSRFSecret(secret []byte) error {
+	_, err := db.DB.Exec(insertCSRFSecret, hex.EncodeToString(secret))
+	return err
+}
+
+// persistLastPaymentInfo stores the last payment height and paidOn timestamp
+// in the database.
+func (db *PostgresDB) persistLastPaymentInfo(height uint32, paidOn int64) error {
+	tx, err := db.DB.Begin()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(insertLastPaymentHeight, height)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	_, err = tx.Exec(insertLastPaymentPaidOn, paidOn)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	return tx.Commit()
+}
+
+// loadLastPaymentInfo retrieves the last payment height and paidOn timestamp
+// from the database.
+func (db *PostgresDB) loadLastPaymentInfo() (uint32, int64, error) {
+	const funcName = "loadLastPaymentInfo"
+
+	var height uint32
+	err := db.DB.QueryRow(selectLastPaymentHeight).Scan(&height)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no value found for lastpaymentheight",
+				funcName)
+			return 0, 0, dbError(ErrValueNotFound, desc)
+		}
+
+		return 0, 0, err
+	}
+
+	var paidOn int64
+	err = db.DB.QueryRow(selectLastPaymentPaidOn).Scan(&paidOn)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no value found for lastpaymentpaidon",
+				funcName)
+			return 0, 0, dbError(ErrValueNotFound, desc)
+		}
+
+		return 0, 0, err
+	}
+
+	return height, paidOn, nil
+}
+
+// persistLastPaymentCreatedOn stores the last payment createdOn timestamp in
+// the database.
+func (db *PostgresDB) persistLastPaymentCreatedOn(createdOn int64) error {
+	_, err := db.DB.Exec(insertLastPaymentCreatedOn, createdOn)
+	return err
+}
+
+// loadLastPaymentCreatedOn retrieves the last payment createdOn timestamp from
+// the database.
+func (db *PostgresDB) loadLastPaymentCreatedOn() (int64, error) {
+	const funcName = "loadLastPaymentCreatedOn"
+	var createdOn int64
+	err := db.DB.QueryRow(selectLastPaymentCreatedOn).Scan(&createdOn)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no value found for lastpaymentcreatedon",
+				funcName)
+			return 0, dbError(ErrValueNotFound, desc)
+		}
+
+		return 0, err
+	}
+	return createdOn, nil
+}
+
+// persistAccount saves the account to the database. Before persisting the
+// account, it sets the createdOn timestamp. Returns an error if an account
+// already exists with the same ID.
+func (db *PostgresDB) persistAccount(acc *Account) error {
+	const funcName = "persistAccount"
+	_, err := db.DB.Exec(insertAccount, acc.UUID, acc.Address, uint64(time.Now().Unix()))
+	if err != nil {
+
+		var pqError *pq.Error
+		if errors.As(err, &pqError) {
+			if pqError.Code.Name() == "unique_violation" {
+				desc := fmt.Sprintf("%s: account %s already exists", funcName,
+					acc.UUID)
+				return dbError(ErrValueFound, desc)
+			}
+		}
+
+		return err
+	}
+	return nil
+}
+
+// fetchAccount fetches the account referenced by the provided id. Returns
+// an error if the account is not found.
+func (db *PostgresDB) fetchAccount(id string) (*Account, error) {
+	const funcName = "fetchAccount"
+	var uuid, address string
+	var createdOn uint64
+	err := db.DB.QueryRow(selectAccount, id).Scan(&uuid, &address, &createdOn)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no account found for id %s", funcName, id)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+	return &Account{uuid, address, createdOn}, nil
+}
+
+// deleteAccount purges the referenced account from the database.
+func (db *PostgresDB) deleteAccount(id string) error {
+	_, err := db.DB.Exec(deleteAccount, id)
+	return err
+}
+
+// fetchPayment fetches the payment referenced by the provided id. Returns an
+// error if the payment is not found.
+func (db *PostgresDB) fetchPayment(id string) (*Payment, error) {
+	const funcName = "fetchPayment"
+	var uuid, account, transactionID, sourceBlockHash, sourceCoinbase string
+	var estimatedMaturity, height, paidOnHeight uint32
+	var amount, createdOn int64
+
+	err := db.DB.QueryRow(selectPayment, id).Scan(&uuid, &account, &estimatedMaturity,
+		&height, &amount, &createdOn, &paidOnHeight, &transactionID,
+		&sourceBlockHash, &sourceCoinbase)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no payment found for id %s", funcName, id)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+	return &Payment{uuid, account, estimatedMaturity,
+		height, dcrutil.Amount(amount), createdOn, paidOnHeight, transactionID,
+		&PaymentSource{sourceBlockHash, sourceCoinbase}}, nil
+}
+
+// PersistPayment saves a payment to the database.
+func (db *PostgresDB) PersistPayment(p *Payment) error {
+	const funcName = "PersistPayment"
+
+	_, err := db.DB.Exec(insertPayment,
+		p.UUID, p.Account, p.EstimatedMaturity, p.Height, p.Amount, p.CreatedOn,
+		p.PaidOnHeight, p.TransactionID, p.Source.BlockHash, p.Source.Coinbase)
+	if err != nil {
+
+		var pqError *pq.Error
+		if errors.As(err, &pqError) {
+			if pqError.Code.Name() == "unique_violation" {
+				desc := fmt.Sprintf("%s: payment %s already exists", funcName,
+					p.UUID)
+				return dbError(ErrValueFound, desc)
+			}
+		}
+
+		return err
+	}
+	return nil
+}
+
+// updatePayment persists the updated payment to the database.
+func (db *PostgresDB) updatePayment(p *Payment) error {
+	_, err := db.DB.Exec(updatePayment,
+		p.UUID, p.Account, p.EstimatedMaturity, p.Height, p.Amount, p.CreatedOn,
+		p.PaidOnHeight, p.TransactionID, p.Source.BlockHash, p.Source.Coinbase)
+	return err
+}
+
+// deletePayment purges the referenced payment from the database. Note that
+// archived payments cannot be deleted.
+func (db *PostgresDB) deletePayment(id string) error {
+	_, err := db.DB.Exec(deletePayment, id)
+	return err
+}
+
+// ArchivePayment removes the associated payment from active payments and archives it.
+func (db *PostgresDB) ArchivePayment(p *Payment) error {
+	const funcName = "ArchivePayment"
+
+	tx, err := db.DB.Begin()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(deletePayment, p.UUID)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	aPmt := NewPayment(p.Account, p.Source, p.Amount, p.Height,
+		p.EstimatedMaturity)
+
+	_, err = tx.Exec(insertArchivedPayment,
+		aPmt.UUID, aPmt.Account, aPmt.EstimatedMaturity, aPmt.Height, aPmt.Amount,
+		aPmt.CreatedOn, aPmt.PaidOnHeight, aPmt.TransactionID, aPmt.Source.BlockHash,
+		p.Source.Coinbase)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	return tx.Commit()
+}
+
+// fetchPaymentsAtHeight returns all payments sourcing from orphaned blocks at
+// the provided height.
+func (db *PostgresDB) fetchPaymentsAtHeight(height uint32) ([]*Payment, error) {
+	rows, err := db.DB.Query(selectPaymentsAtHeight, height)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodePaymentRows(rows)
+}
+
+// fetchPendingPayments fetches all unpaid payments.
+func (db *PostgresDB) fetchPendingPayments() ([]*Payment, error) {
+	rows, err := db.DB.Query(selectPendingPayments)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodePaymentRows(rows)
+}
+
+// pendingPaymentsForBlockHash returns the number of pending payments with the
+// provided block hash as their source.
+func (db *PostgresDB) pendingPaymentsForBlockHash(blockHash string) (uint32, error) {
+	var count uint32
+	err := db.DB.QueryRow(countPaymentsAtBlockHash, blockHash).Scan(&count)
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+// archivedPayments fetches all archived payments. List is ordered, most
+// recent comes first.
+func (db *PostgresDB) archivedPayments() ([]*Payment, error) {
+	rows, err := db.DB.Query(selectArchivedPayments)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodePaymentRows(rows)
+}
+
+// maturePendingPayments fetches all mature pending payments at the
+// provided height.
+func (db *PostgresDB) maturePendingPayments(height uint32) (map[string][]*Payment, error) {
+	rows, err := db.DB.Query(selectMaturePendingPayments, height)
+	if err != nil {
+		return nil, err
+	}
+
+	payments, err := decodePaymentRows(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	pmts := make(map[string][]*Payment)
+	for _, pmt := range payments {
+		set, ok := pmts[pmt.Source.BlockHash]
+		if !ok {
+			set = make([]*Payment, 0)
+		}
+		set = append(set, pmt)
+		pmts[pmt.Source.BlockHash] = set
+	}
+
+	return pmts, nil
+}
+
+// fetchShare fetches the share referenced by the provided id. Returns an error
+// if the share is not found.
+func (db *PostgresDB) fetchShare(id string) (*Share, error) {
+	const funcName = "fetchShare"
+	var uuid, account, weight string
+	var createdOn int64
+	err := db.DB.QueryRow(selectShare, id).Scan(&uuid, &account, &weight, &createdOn)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no share found for id %s", funcName, id)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+
+	weightRat, ok := new(big.Rat).SetString(weight)
+	if !ok {
+		desc := fmt.Sprintf("%s: unable to decode rat string: %v",
+			funcName, err)
+		return nil, dbError(ErrParse, desc)
+	}
+
+	return &Share{uuid, account, weightRat, createdOn}, nil
+}
+
+// PersistShare saves a share to the database. Returns an error if a share
+// already exists with the same ID.
+func (db *PostgresDB) PersistShare(share *Share) error {
+	const funcName = "PersistShare"
+
+	_, err := db.DB.Exec(insertShare, share.UUID, share.Account, share.Weight.RatString(), share.CreatedOn)
+	if err != nil {
+
+		var pqError *pq.Error
+		if errors.As(err, &pqError) {
+			if pqError.Code.Name() == "unique_violation" {
+				desc := fmt.Sprintf("%s: share %s already exists", funcName,
+					share.UUID)
+				return dbError(ErrValueFound, desc)
+			}
+		}
+
+		return err
+	}
+	return nil
+}
+
+// ppsEligibleShares fetches all shares created before or at the provided time.
+func (db *PostgresDB) ppsEligibleShares(max int64) ([]*Share, error) {
+	rows, err := db.DB.Query(selectSharesOnOrBeforeTime, max)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeShareRows(rows)
+}
+
+// pplnsEligibleShares fetches all shares created after the provided time.
+func (db *PostgresDB) pplnsEligibleShares(min int64) ([]*Share, error) {
+	rows, err := db.DB.Query(selectSharesAfterTime, min)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeShareRows(rows)
+}
+
+// pruneShares removes shares with a createdOn time earlier than the provided
+// time.
+func (db *PostgresDB) pruneShares(minNano int64) error {
+	_, err := db.DB.Exec(deleteShareCreatedBefore, minNano)
+	return err
+}
+
+// fetchAcceptedWork fetches the accepted work referenced by the provided id.
+// Returns an error if the work is not found.
+func (db *PostgresDB) fetchAcceptedWork(id string) (*AcceptedWork, error) {
+	const funcName = "fetchAcceptedWork"
+
+	var uuid, blockhash, prevhash, minedby, miner string
+	var confirmed bool
+	var height uint32
+	var createdOn int64
+	err := db.DB.QueryRow(selectAcceptedWork, id).Scan(&uuid, &blockhash, &prevhash, &height,
+		&minedby, &miner, &createdOn, &confirmed)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no work found for id %s", funcName, id)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+
+	return &AcceptedWork{uuid, blockhash, prevhash, height,
+		minedby, miner, createdOn, confirmed}, nil
+}
+
+// persistAcceptedWork saves the accepted work to the database.
+func (db *PostgresDB) persistAcceptedWork(work *AcceptedWork) error {
+	const funcName = "persistAcceptedWork"
+
+	_, err := db.DB.Exec(insertAcceptedWork, work.UUID, work.BlockHash, work.PrevHash,
+		work.Height, work.MinedBy, work.Miner, work.CreatedOn, work.Confirmed)
+	if err != nil {
+
+		var pqError *pq.Error
+		if errors.As(err, &pqError) {
+			if pqError.Code.Name() == "unique_violation" {
+				desc := fmt.Sprintf("%s: work %s already exists", funcName,
+					work.UUID)
+				return dbError(ErrValueFound, desc)
+			}
+		}
+
+		return err
+	}
+	return nil
+}
+
+// updateAcceptedWork persists modifications to an existing work. Returns an
+// error if the work is not found.
+func (db *PostgresDB) updateAcceptedWork(work *AcceptedWork) error {
+	const funcName = "updateAcceptedWork"
+
+	result, err := db.DB.Exec(updateAcceptedWork,
+		work.UUID, work.BlockHash, work.PrevHash,
+		work.Height, work.MinedBy, work.Miner, work.CreatedOn, work.Confirmed)
+	if err != nil {
+		return err
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if rowsAffected == 0 {
+		desc := fmt.Sprintf("%s: work %s not found", funcName, work.UUID)
+		return dbError(ErrValueNotFound, desc)
+	}
+
+	return nil
+}
+
+// deleteAcceptedWork removes the associated accepted work from the database.
+func (db *PostgresDB) deleteAcceptedWork(id string) error {
+	_, err := db.DB.Exec(deleteAcceptedWork, id)
+	return err
+}
+
+// listMinedWork returns work data associated with all blocks mined by the pool
+// regardless of whether they are confirmed or not.
+//
+// List is ordered, most recent comes first.
+func (db *PostgresDB) listMinedWork() ([]*AcceptedWork, error) {
+	rows, err := db.DB.Query(selectMinedWork)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeWorkRows(rows)
+}
+
+// fetchUnconfirmedWork returns all work which is not confirmed as mined with
+// height less than the provided height.
+func (db *PostgresDB) fetchUnconfirmedWork(height uint32) ([]*AcceptedWork, error) {
+	rows, err := db.DB.Query(selectUnconfirmedWork, height)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeWorkRows(rows)
+}
+
+// fetchJob fetches the job referenced by the provided id. Returns an error if
+// the job is not found.
+func (db *PostgresDB) fetchJob(id string) (*Job, error) {
+	const funcName = "fetchJob"
+	var uuid, header string
+	var height uint32
+	err := db.DB.QueryRow(selectJob, id).Scan(&uuid, &header, &height)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			desc := fmt.Sprintf("%s: no job found for id %s", funcName, id)
+			return nil, dbError(ErrValueNotFound, desc)
+		}
+
+		return nil, err
+	}
+	return &Job{uuid, height, header}, nil
+}
+
+// persistJob saves the job to the database. Returns an error if an account
+// already exists with the same ID.
+func (db *PostgresDB) persistJob(job *Job) error {
+	const funcName = "persistJob"
+
+	_, err := db.DB.Exec(insertJob, job.UUID, job.Height, job.Header)
+	if err != nil {
+
+		var pqError *pq.Error
+		if errors.As(err, &pqError) {
+			if pqError.Code.Name() == "unique_violation" {
+				desc := fmt.Sprintf("%s: job %s already exists", funcName,
+					job.UUID)
+				return dbError(ErrValueFound, desc)
+			}
+		}
+
+		return err
+	}
+	return nil
+}
+
+// deleteJob removes the associated job from the database.
+func (db *PostgresDB) deleteJob(id string) error {
+	_, err := db.DB.Exec(deleteJob, id)
+	return err
+}
+
+// deleteJobsBeforeHeight removes all jobs with heights less than the provided
+// height.
+func (db *PostgresDB) deleteJobsBeforeHeight(height uint32) error {
+	_, err := db.DB.Exec(deleteJobBeforeHeight, height)
+	return err
+}
diff --git a/pool/share.go b/pool/share.go
index e34eba10..9429b84f 100644
--- a/pool/share.go
+++ b/pool/share.go
@@ -158,8 +158,7 @@ func (db *BoltDB) ppsEligibleShares(max int64) ([]*Share, error) {
 	return eligibleShares, err
 }
 
-// pplnsEligibleShares fetches all shares keyed greater than the provided
-// minimum.
+// pplnsEligibleShares fetches all shares created after the provided time.
 func (db *BoltDB) pplnsEligibleShares(min int64) ([]*Share, error) {
 	funcName := "pplnsEligibleShares"
 	eligibleShares := make([]*Share, 0)
diff --git a/pool/sql_queries.go b/pool/sql_queries.go
new file mode 100644
index 00000000..41c47266
--- /dev/null
+++ b/pool/sql_queries.go
@@ -0,0 +1,372 @@
+// Copyright (c) 2020 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package pool
+
+const (
+	createTableMetadata = `
+	CREATE TABLE IF NOT EXISTS metadata (
+		key      TEXT PRIMARY KEY,
+		value    TEXT NOT NULL
+	);`
+
+	createTableAccounts = `
+	CREATE TABLE IF NOT EXISTS accounts (
+		uuid      TEXT PRIMARY KEY,
+		address   TEXT NOT NULL,
+		createdon INT8 NOT NULL
+	);`
+
+	createTablePayments = `
+	CREATE TABLE IF NOT EXISTS payments (
+		uuid              TEXT PRIMARY KEY,
+		account           TEXT NOT NULL,
+		estimatedmaturity INT8 NOT NULL,
+		height            INT8 NOT NULL,
+		amount            INT8 NOT NULL,
+		createdon         INT8 NOT NULL,
+		paidonheight      INT8 NOT NULL,
+		transactionid     TEXT NOT NULL,
+		sourceblockhash   TEXT NOT NULL,
+		sourcecoinbase    TEXT NOT NULL
+	);`
+
+	createTableArchivedPayments = `
+	CREATE TABLE IF NOT EXISTS archivedpayments (
+		uuid              TEXT PRIMARY KEY,
+		account           TEXT NOT NULL,
+		estimatedmaturity INT8 NOT NULL,
+		height            INT8 NOT NULL,
+		amount            INT8 NOT NULL,
+		createdon         INT8 NOT NULL,
+		paidonheight      INT8 NOT NULL,
+		transactionid     TEXT NOT NULL,
+		sourceblockhash   TEXT NOT NULL,
+		sourcecoinbase    TEXT NOT NULL
+	);`
+
+	createTableJobs = `
+	CREATE TABLE IF NOT EXISTS jobs (
+		uuid   TEXT PRIMARY KEY,
+		height INT8 NOT NULL,
+		header TEXT NOT NULL
+	);`
+
+	createTableShares = `
+	CREATE TABLE IF NOT EXISTS shares (
+		uuid      TEXT PRIMARY KEY,
+		account   TEXT NOT NULL,
+		weight    TEXT NOT NULL,
+		createdon INT8 NOT NULL
+	);`
+
+	createTableAcceptedWork = `
+	CREATE TABLE IF NOT EXISTS acceptedwork (
+		uuid      TEXT    PRIMARY KEY,
+		blockhash TEXT    NOT NULL,
+		prevhash  TEXT    NOT NULL,
+		height    INT8    NOT NULL,
+		minedby   TEXT    NOT NULL,
+		miner     TEXT    NOT NULL,
+		createdon INT8    NOT NULL,
+		confirmed BOOLEAN NOT NULL
+	);`
+
+	selectPoolMode = `
+	SELECT value
+	FROM metadata
+	WHERE key='poolmode';`
+
+	insertPoolMode = `
+	INSERT INTO metadata(key, value)
+	VALUES ('poolmode', $1)
+	ON CONFLICT (key)
+	DO UPDATE SET value=$1;`
+
+	selectCSRFSecret = `
+	SELECT value
+	FROM metadata
+	WHERE key='csrfsecret';`
+
+	insertCSRFSecret = `
+	INSERT INTO metadata(key, value)
+	VALUES ('csrfsecret', $1)
+	ON CONFLICT (key)
+	DO UPDATE SET value=$1;`
+
+	selectLastPaymentHeight = `
+	SELECT value
+	FROM metadata
+	WHERE key='lastpaymentheight';`
+
+	insertLastPaymentHeight = `
+	INSERT INTO metadata(key, value)
+	VALUES ('lastpaymentheight', $1)
+	ON CONFLICT (key)
+	DO UPDATE SET value=$1;`
+
+	selectLastPaymentPaidOn = `
+	SELECT value
+	FROM metadata
+	WHERE key='lastpaymentpaidon';`
+
+	insertLastPaymentPaidOn = `
+	INSERT INTO metadata(key, value)
+	VALUES ('lastpaymentpaidon', $1)
+	ON CONFLICT (key)
+	DO UPDATE SET value=$1;`
+
+	selectLastPaymentCreatedOn = `
+	SELECT value
+	FROM metadata
+	WHERE key='lastpaymentcreatedon';`
+
+	insertLastPaymentCreatedOn = `
+	INSERT INTO metadata(key, value)
+	VALUES ('lastpaymentcreatedon', $1)
+	ON CONFLICT (key)
+	DO UPDATE SET value=$1;`
+
+	insertAccount = `
+	INSERT INTO accounts(
+		uuid, address, createdon
+	) VALUES ($1,$2,$3);`
+
+	selectAccount = `
+	SELECT
+		uuid, address, createdon
+	FROM accounts
+	WHERE uuid=$1;`
+
+	deleteAccount = `DELETE FROM accounts WHERE uuid=$1;`
+
+	insertPayment = `
+	INSERT INTO payments(
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	)
+	VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10);`
+
+	selectPayment = `
+	SELECT
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	FROM payments
+	WHERE uuid=$1;`
+
+	deletePayment = `DELETE FROM payments WHERE uuid=$1;`
+
+	updatePayment = `
+	UPDATE payments
+	SET
+		account=$2,
+		estimatedmaturity=$3,
+		height=$4,
+		amount=$5,
+		createdon=$6,
+		paidonheight=$7,
+		transactionid=$8,
+		sourceblockhash=$9,
+		sourcecoinbase=$10
+	WHERE uuid=$1;`
+
+	insertArchivedPayment = `
+	INSERT INTO archivedpayments(
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	)
+	VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10);`
+
+	selectPaymentsAtHeight = `
+	SELECT
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	FROM payments
+	WHERE paidonheight=0
+	AND $1>(estimatedmaturity+1);`
+
+	selectPendingPayments = `
+	SELECT
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	FROM payments
+	WHERE paidonheight=0;`
+
+	countPaymentsAtBlockHash = `
+	SELECT count(1)
+	FROM payments
+	WHERE paidonheight=0
+	AND sourceblockhash=$1;`
+
+	selectArchivedPayments = `
+	SELECT
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	FROM archivedpayments
+	ORDER BY height DESC;`
+
+	selectMaturePendingPayments = `
+	SELECT
+		uuid,
+		account,
+		estimatedmaturity,
+		height,
+		amount,
+		createdon,
+		paidonheight,
+		transactionid,
+		sourceblockhash,
+		sourcecoinbase
+	FROM payments
+	WHERE paidonheight=0
+	AND (estimatedmaturity+1)<=$1;`
+
+	selectShare = `
+	SELECT
+		uuid, account, weight, createdon
+	FROM shares
+	WHERE uuid=$1;`
+
+	insertShare = `
+	INSERT INTO shares(
+		uuid, account, weight, createdon
+	)
+	VALUES ($1,$2,$3,$4);`
+
+	selectSharesOnOrBeforeTime = `
+	SELECT
+		uuid, account, weight, createdon
+	FROM shares
+	WHERE createdon <= $1`
+
+	selectSharesAfterTime = `
+	SELECT
+		uuid, account, weight, createdon
+	FROM shares
+	WHERE createdon > $1`
+
+	deleteShareCreatedBefore = `DELETE FROM shares WHERE createdon < $1`
+
+	selectAcceptedWork = `
+	SELECT
+		uuid,
+		blockhash,
+		prevhash,
+		height,
+		minedby,
+		miner,
+		createdon,
+		confirmed
+	FROM acceptedwork
+	WHERE uuid=$1;`
+
+	insertAcceptedWork = `
+	INSERT INTO acceptedwork(
+		uuid,
+		blockhash,
+		prevhash,
+		height,
+		minedby,
+		miner,
+		createdon,
+		confirmed
+	) VALUES ($1,$2,$3,$4,$5,$6,$7,$8);`
+
+	updateAcceptedWork = `
+	UPDATE acceptedwork
+	SET
+		blockhash=$2,
+		prevhash=$3,
+		height=$4,
+		minedby=$5,
+		miner=$6,
+		createdon=$7,
+		confirmed=$8
+		WHERE uuid=$1;`
+
+	deleteAcceptedWork = `DELETE FROM acceptedwork WHERE uuid=$1;`
+
+	selectMinedWork = `
+	SELECT
+		uuid,
+		blockhash,
+		prevhash,
+		height,
+		minedby,
+		miner,
+		createdon,
+		confirmed
+	FROM acceptedwork
+	ORDER BY height DESC;`
+
+	selectUnconfirmedWork = `
+	SELECT
+		uuid,
+		blockhash,
+		prevhash,
+		height,
+		minedby,
+		miner,
+		createdon,
+		confirmed
+	FROM acceptedwork
+	WHERE $1>height
+	AND confirmed=false;`
+
+	selectJob = `SELECT uuid, header, height FROM jobs WHERE uuid=$1;`
+
+	insertJob = `INSERT INTO jobs(uuid, height, header) VALUES ($1,$2,$3);`
+
+	deleteJob = `DELETE FROM jobs WHERE uuid=$1;`
+
+	deleteJobBeforeHeight = `DELETE FROM jobs WHERE height < $1;`
+)