diff --git a/.github/workflows/cypress.yml b/.github/workflows/cypress.yml
index 2234d402a..317de996f 100644
--- a/.github/workflows/cypress.yml
+++ b/.github/workflows/cypress.yml
@@ -22,7 +22,7 @@ jobs:
       uses: cypress-io/github-action@v5
       with:
         wait-on: 'https://localhost:9443'
-        wait-on-timeout: 120
+        wait-on-timeout: 180
         build: sh ./build_dbhub_docker_and_local.sh
         start: yarn docker:startlocal
         command: yarn cypress:test
diff --git a/.gitignore b/.gitignore
index 165c00425..114e0d9ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,3 +56,7 @@ webui/js/markdown-editor.js
 
 # Local secrets
 .env
+
+# Other files
+headers.out
+curl_commands.txt
diff --git a/README.md b/README.md
index 7c3d2edd8..5f885d129 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ or run it locally for your own users.
 * [Minio](https://minio.io) - release 2016-11-26T02:23:47Z and later are known to work.
 * [NodeJS](https://nodejs.org) - version 18.x is known to work, others are untested.
 * [PostgreSQL](https://www.postgresql.org) - version 13 and above are known to work.
+* [RabbitMQ](https://www.rabbitmq.com) - version 3.10.x is known to work, others are untested.
 * [Yarn](https://classic.yarnpkg.com) - version 1.22.x.  Not Yarn 2.x or greater.
 
 ### Subdirectories
@@ -31,6 +32,7 @@ or run it locally for your own users.
 * [default_licences](default_licences/) - Useful Open Source licences suitable for databases.
 * [db4s](db4s/) - REST server which [DB Browser for SQLite](http://sqlitebrowser.org)
   and [Dio](https://github.com/sqlitebrowser/dio) use for communicating with DBHub.io.
+* [live](live/) - Internal daemon which manages live SQLite databases.
 * [webui](webui/) - The main public facing webUI.
 
 ### Libraries for accessing DBHub.io via API
diff --git a/api/handlers.go b/api/handlers.go
index 20b5e59d6..bcb3401d1 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -2,11 +2,16 @@ package main
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
+	"mime/multipart"
 	"net/http"
 	"net/url"
+	"os"
+	"sort"
 
+	sqlite "github.com/gwenn/gosqlite"
 	com "github.com/sqlitebrowser/dbhub.io/common"
 )
 
@@ -28,6 +33,17 @@ func branchesHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	dbFolder := "/"
 
+	// If the database is a live database, we return an error message
+	isLive, _, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, "That database is a live database.  It doesn't have branches.", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve the branch list for the database
 	brList, err := com.BranchListResponse(dbOwner, dbFolder, dbName)
 	if err != nil {
@@ -52,19 +68,19 @@ func branchesHandler(w http.ResponseWriter, r *http.Request) {
 //   $ curl -F apikey="YOUR_API_KEY_HERE" \
 //       -F dbowner="justinclift" \
 //       -F dbname="Join Testing.sqlite" \
-//       -F table="tablename" https://api.dbhub.io/v1/columns
+//       -F table="table1" https://api.dbhub.io/v1/columns
 //   * "apikey" is one of your API keys.  These can be generated from your Settings page once logged in
 //   * "dbowner" is the owner of the database
 //   * "dbname" is the name of the database
 //   * "table" is the name of the table or view
 func columnsHandler(w http.ResponseWriter, r *http.Request) {
-	// Do auth check, grab request info, open the database
-	sdb, httpStatus, err := collectInfoAndOpen(w, r)
+	// Do auth check, grab request info
+	loggedInUser, dbOwner, dbName, _, httpStatus, err := collectInfo(w, r)
 	if err != nil {
 		jsonErr(w, err.Error(), httpStatus)
 		return
 	}
-	defer sdb.Close()
+	dbFolder := "/"
 
 	// Extract the table name
 	table, err := com.GetFormTable(r, false)
@@ -79,13 +95,103 @@ func columnsHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Retrieve the list of columns for the table
-	cols, err := sdb.Columns("", table)
+	// Check if the database is a live database, and get the node/queue to send the request to
+	isLive, liveNode, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	// If a live database has been uploaded but doesn't have a live node handling its requests, then create one
+	if isLive && liveNode == "" {
+		// Send a request to the AMQP backend to setup a node with the database
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// If it's a standard database, process it locally.  Else send the query to our AMQP backend
+	var cols []sqlite.Column
+	if !isLive {
+		// Get Minio bucket and object id for the SQLite file
+		bucket, id, _, err := com.MinioLocation(dbOwner, dbFolder, dbName, "", loggedInUser)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Sanity check
+		if id == "" {
+			// The requested database wasn't found, or the user doesn't have permission to access it
+			jsonErr(w, "Requested database not found", http.StatusNotFound)
+			return
+		}
+
+		// Retrieve the database from Minio, then open it
+		var sdb *sqlite.Conn
+		sdb, err = com.OpenSQLiteDatabase(bucket, id)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer sdb.Close()
+
+		// Verify the requested table or view we're about to query does exist
+		var tablesViews []string
+		tablesViews, err = com.TablesAndViews(sdb, dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		tableOrViewFound := false
+		for _, t := range tablesViews {
+			if t == table {
+				tableOrViewFound = true
+			}
+		}
+		if !tableOrViewFound {
+			jsonErr(w, "Provided table or view name doesn't exist in this database", http.StatusInternalServerError)
+			return
+		}
+
+		// Retrieve the list of columns for the table
+		cols, err = sdb.Columns("", table)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Send the columns request to our AMQP backend
+		var rawResponse []byte
+		rawResponse, err = com.MQSendRequest(com.AmqpChan, liveNode, "columns", loggedInUser, dbOwner, dbName, table)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+
+		// Decode the response
+		var resp com.LiveDBColumnsResponse
+		err = json.Unmarshal(rawResponse, &resp)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+		if resp.Error != "" {
+			err = errors.New(resp.Error)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if resp.Node == "" {
+			log.Printf("In API (Live) columnsHandler().  A node responded, but didn't identify itself.")
+			return
+		}
+		cols = resp.Columns
+	}
+
 	// Transfer the column info into our own structure, for better json formatting
 	var jsonCols []com.APIJSONColumn
 	for _, j := range cols {
@@ -124,6 +230,17 @@ func commitsHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	dbFolder := "/"
 
+	// If the database is a live database, we return an error message
+	isLive, _, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, "That database is a live database.  It doesn't have commits.", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve the commits
 	commits, err := com.GetCommitList(dbOwner, dbFolder, dbName)
 	if err != nil {
@@ -141,10 +258,13 @@ func commitsHandler(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, string(jsonData))
 }
 
-// databasesHandler returns the list of databases in the requesting users account
+// databasesHandler returns the list of databases in the requesting users account.
+// If the new (optional) "live" boolean text field is set to true, then it will return the list of live
+// databases.  Otherwise, it will return the list of standard databases.
 // This can be run from the command line using curl, like this:
-//   $ curl -F apikey="YOUR_API_KEY_HERE" https://api.dbhub.io/v1/databases
+//   $ curl -F apikey="YOUR_API_KEY_HERE" -F live="true" https://api.dbhub.io/v1/databases
 //   * "apikey" is one of your API keys.  These can be generated from your Settings page once logged in
+//   * "live" is whether to show Live databases, or standard ones
 func databasesHandler(w http.ResponseWriter, r *http.Request) {
 	// Authenticate the request
 	loggedInUser, err := checkAuth(w, r)
@@ -153,14 +273,32 @@ func databasesHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Retrieve the list of databases in the user account
-	var databases []com.DBInfo
-	databases, err = com.UserDBs(loggedInUser, com.DB_BOTH)
+	// Get "live" boolean value, if provided by the caller
+	var live bool
+	live, err = com.GetFormLive(r)
 	if err != nil {
-		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		jsonErr(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
+	// Retrieve the list of databases in the user account
+	var databases []com.DBInfo
+	if !live {
+		// Get the list of standard databases
+		databases, err = com.UserDBs(loggedInUser, com.DB_BOTH)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Get the list of live databases
+		databases, err = com.LiveUserDBs(loggedInUser)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
 	// Extract just the database names
 	var list []string
 	for _, j := range databases {
@@ -191,7 +329,8 @@ func deleteHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Validate the database name
-	dbName, err := com.GetDatabase(r, false)
+	var dbName string
+	dbName, err = com.GetDatabase(r, false)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusBadRequest)
 		return
@@ -199,12 +338,32 @@ func deleteHandler(w http.ResponseWriter, r *http.Request) {
 	dbOwner := loggedInUser
 	dbFolder := "/"
 
-	// Invalidate the memcache data for the database
-	err = com.InvalidateCacheEntry(loggedInUser, dbOwner, dbFolder, dbName, "") // Empty string indicates "for all versions"
+	// Check if the database exists
+	exists, err := com.CheckDBPermissions(loggedInUser, dbOwner, dbFolder, dbName, false)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
+	if !exists {
+		jsonErr(w, "Database does not exist, or user isn't authorised to access it", http.StatusNotFound)
+		return
+	}
+
+	// For a standard database, invalidate its memcache data
+	var isLive bool
+	var liveNode string
+	isLive, liveNode, err = com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusNotFound)
+		return
+	}
+	if !isLive {
+		err = com.InvalidateCacheEntry(loggedInUser, dbOwner, dbFolder, dbName, "") // Empty string indicates "for all versions"
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
 
 	// Delete the database
 	err = com.DeleteDatabase(dbOwner, dbFolder, dbName)
@@ -213,6 +372,44 @@ func deleteHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Delete the database from Minio too
+	bucket := fmt.Sprintf("live-%s", dbOwner)
+	id := dbName
+	err = com.MinioDeleteDatabase("API server", dbOwner, dbName, bucket, id)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// For a live database, tell our AMQP backend to delete the database file
+	if isLive {
+		var rawResponse []byte
+		rawResponse, err = com.MQSendRequest(com.AmqpChan, liveNode, "delete", loggedInUser, dbOwner, dbName, "")
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+
+		// Decode the response
+		var resp com.LiveDBErrorResponse
+		err = json.Unmarshal(rawResponse, &resp)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+		if resp.Error != "" {
+			err = errors.New(resp.Error)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if resp.Node == "" {
+			log.Printf("In API (Live) deleteHandler().  A node responded, but didn't identify itself.")
+			return
+		}
+	}
+
 	// Return a "success" message
 	z := com.StatusResponseContainer{Status: "OK"}
 	jsonData, err := json.MarshalIndent(z, "", "  ")
@@ -334,6 +531,50 @@ func diffHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Check permissions of the first database
+	var allowed bool
+	allowed, err = com.CheckDBPermissions(loggedInUser, dbOwnerA, "/", dbNameA, false)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if !allowed {
+		jsonErr(w, "Database not found", http.StatusNotFound)
+		return
+	}
+
+	// Check permissions of the second database
+	allowed, err = com.CheckDBPermissions(loggedInUser, dbOwnerB, "/", dbNameB, false)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if !allowed {
+		jsonErr(w, "Database not found", http.StatusNotFound)
+		return
+	}
+
+	// If either database is a live database, we return an error message
+	var isLive bool
+	isLive, _, err = com.CheckDBLive(dbOwnerA, "/", dbNameA)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, fmt.Sprintf("'%s/%s' is a live database.  It doesn't support diffs.", dbOwnerA, dbNameA), http.StatusBadRequest)
+		return
+	}
+	isLive, _, err = com.CheckDBLive(dbOwnerB, "/", dbNameB)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, fmt.Sprintf("'%s/%s' is a live database.  It doesn't support diffs.", dbOwnerB, dbNameB), http.StatusBadRequest)
+		return
+	}
+
 	// Perform diff
 	diffs, err := com.Diff(dbOwnerA, "/", dbNameA, ca, dbOwnerB, "/", dbNameB, cb, loggedInUser, mergeStrategy, includeData)
 	if err != nil {
@@ -381,41 +622,113 @@ func downloadHandler(w http.ResponseWriter, r *http.Request) {
 //   * "dbowner" is the owner of the database
 //   * "dbname" is the name of the database
 func indexesHandler(w http.ResponseWriter, r *http.Request) {
-	// Do auth check, grab request info, open the database
-	sdb, httpStatus, err := collectInfoAndOpen(w, r)
+	// Do auth check, grab request info
+	loggedInUser, dbOwner, dbName, _, httpStatus, err := collectInfo(w, r)
 	if err != nil {
 		jsonErr(w, err.Error(), httpStatus)
 		return
 	}
-	defer sdb.Close()
+	dbFolder := "/"
 
-	// Retrieve the list of indexes
-	idx, err := sdb.Indexes("")
+	// Check if the database is a live database, and get the node/queue to send the request to
+	isLive, liveNode, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	// Retrieve the column details for each index
+	// If a live database has been uploaded but doesn't have a live node handling its requests, then create one
+	if isLive && liveNode == "" {
+		// Send a request to the AMQP backend to set up a node with the database
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// If it's a standard database, process it locally.  Else send the query to our AMQP backend
 	var indexes []com.APIJSONIndex
-	for nam, tab := range idx {
-		oneIndex := com.APIJSONIndex{
-			Name:    nam,
-			Table:   tab,
-			Columns: []com.APIJSONIndexColumn{},
+	if !isLive {
+		// Get Minio bucket and object id for the SQLite file
+		bucket, id, _, err := com.MinioLocation(dbOwner, dbFolder, dbName, "", loggedInUser)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Sanity check
+		if id == "" {
+			// The requested database wasn't found, or the user doesn't have permission to access it
+			jsonErr(w, "Requested database not found", http.StatusNotFound)
+			return
 		}
-		cols, err := sdb.IndexColumns("", nam)
+
+		// Retrieve the database from Minio, then open it
+		var sdb *sqlite.Conn
+		sdb, err = com.OpenSQLiteDatabase(bucket, id)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer sdb.Close()
+
+		// Retrieve the list of indexes
+		var idx map[string]string
+		idx, err = sdb.Indexes("")
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Retrieve the details for each index
+		for nam, tab := range idx {
+			oneIndex := com.APIJSONIndex{
+				Name:    nam,
+				Table:   tab,
+				Columns: []com.APIJSONIndexColumn{},
+			}
+			cols, err := sdb.IndexColumns("", nam)
+			if err != nil {
+				jsonErr(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			for _, k := range cols {
+				oneIndex.Columns = append(oneIndex.Columns, com.APIJSONIndexColumn{
+					CID:  k.Cid,
+					Name: k.Name,
+				})
+			}
+			indexes = append(indexes, oneIndex)
+		}
+	} else {
+		// Send the indexes request to our AMQP backend
+		var rawResponse []byte
+		rawResponse, err = com.MQSendRequest(com.AmqpChan, liveNode, "indexes", loggedInUser, dbOwner, dbName, "")
 		if err != nil {
 			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
 			return
 		}
-		for _, k := range cols {
-			oneIndex.Columns = append(oneIndex.Columns, com.APIJSONIndexColumn{
-				CID:  k.Cid,
-				Name: k.Name,
-			})
+
+		// Decode the response
+		var resp com.LiveDBIndexesResponse
+		err = json.Unmarshal(rawResponse, &resp)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
 		}
-		indexes = append(indexes, oneIndex)
+		if resp.Error != "" {
+			err = errors.New(resp.Error)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if resp.Node == "" {
+			log.Printf("In API (Live) indexesHandler().  A node responded, but didn't identify itself.")
+			return
+		}
+		indexes = resp.Indexes
 	}
 
 	// Return the results
@@ -443,6 +756,17 @@ func metadataHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	dbFolder := "/"
 
+	// If the database is a live database, we return an error message
+	isLive, _, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, "That database is a live database.  It doesn't support metadata.", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve the metadata for the database
 	meta, err := com.MetadataResponse(dbOwner, dbFolder, dbName)
 	if err != nil {
@@ -488,7 +812,7 @@ func queryHandler(w http.ResponseWriter, r *http.Request) {
 
 	// Grab the incoming SQLite query
 	rawInput := r.FormValue("sql")
-	decodedStr, err := com.CheckUnicode(rawInput)
+	query, err := com.CheckUnicode(rawInput)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusBadRequest)
 		return
@@ -506,14 +830,43 @@ func queryHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Run the query
-	var data com.SQLiteRecordSet
-	data, err = com.SQLiteRunQueryDefensive(w, r, com.API, dbOwner, dbFolder, dbName, commitID, loggedInUser, decodedStr)
+	// Check if the database is a live database, and get the node/queue to send the request to
+	isLive, liveNode, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	// If a live database has been uploaded but doesn't have a live node handling its requests, then create one
+	if isLive && liveNode == "" {
+		// Send a request to the AMQP backend to set up the database there, ready for querying
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			log.Println(err) // FIXME: Debug output while developing
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// Run the query
+	var data com.SQLiteRecordSet
+	if !isLive {
+		// Standard database
+		data, err = com.SQLiteRunQueryDefensive(w, r, com.QuerySourceAPI, dbOwner, dbFolder, dbName, commitID, loggedInUser, query)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Send the query to the appropriate backend live node
+		data, err = com.LiveQueryDB(com.AmqpChan, liveNode, loggedInUser, dbOwner, dbName, query)
+		if err != nil {
+			log.Println(err) // FIXME: Debug output while developing
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
 	// Return the results
 	jsonData, err := json.MarshalIndent(data.Records, "", "  ")
 	if err != nil {
@@ -539,6 +892,17 @@ func releasesHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	dbFolder := "/"
 
+	// If the database is a live database, we return an error message
+	isLive, _, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, "That database is a live database.  It doesn't support releases.", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve the list of releases
 	rels, err := com.GetReleases(dbOwner, dbFolder, dbName)
 	if err != nil {
@@ -589,22 +953,95 @@ func rootHandler(w http.ResponseWriter, r *http.Request) {
 //   * "dbowner" is the owner of the database
 //   * "dbname" is the name of the database
 func tablesHandler(w http.ResponseWriter, r *http.Request) {
-	// Do auth check, grab request info, open the database
-	sdb, httpStatus, err := collectInfoAndOpen(w, r)
+	// Do auth check, grab request info
+	loggedInUser, dbOwner, dbName, _, httpStatus, err := collectInfo(w, r)
 	if err != nil {
 		jsonErr(w, err.Error(), httpStatus)
 		return
 	}
-	defer sdb.Close()
+	dbFolder := "/"
 
-	// Retrieve the list of tables
-	tables, err := com.Tables(sdb)
+	// Check if the database is a live database, and get the node/queue to send the request to
+	isLive, liveNode, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	// If a live database has been uploaded but doesn't have a live node handling its requests, then create one
+	if isLive && liveNode == "" {
+		// Send a request to the AMQP backend to setup a node with the database
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// If it's a standard database, process it locally.  Else send the query to our AMQP backend
+	var tables []string
+	if !isLive {
+		// Get Minio bucket and object id for the SQLite file
+		bucket, id, _, err := com.MinioLocation(dbOwner, dbFolder, dbName, "", loggedInUser)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Sanity check
+		if id == "" {
+			// The requested database wasn't found, or the user doesn't have permission to access it
+			jsonErr(w, "Requested database not found", http.StatusNotFound)
+			return
+		}
+
+		// Retrieve the database from Minio, then open it
+		var sdb *sqlite.Conn
+		sdb, err = com.OpenSQLiteDatabase(bucket, id)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer sdb.Close()
+
+		// Retrieve the list of tables
+		tables, err = com.Tables(sdb)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Send the columns request to our AMQP backend
+		var rawResponse []byte
+		rawResponse, err = com.MQSendRequest(com.AmqpChan, liveNode, "tables", loggedInUser, dbOwner, dbName, "")
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+
+		// Decode the response
+		var resp com.LiveDBTablesResponse
+		err = json.Unmarshal(rawResponse, &resp)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+		if resp.Error != "" {
+			err = errors.New(resp.Error)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if resp.Node == "" {
+			log.Printf("In API (Live) tablesHandler().  A node responded, but didn't identify itself.")
+			return
+		}
+		tables = resp.Tables
+	}
+
 	// Return the results
+	sort.Strings(tables)
 	jsonData, err := json.MarshalIndent(tables, "", "  ")
 	if err != nil {
 		log.Printf("Error when JSON marshalling returned data in tablesHandler(): %v\n", err)
@@ -629,6 +1066,17 @@ func tagsHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	dbFolder := "/"
 
+	// If the database is a live database, we return an error message
+	isLive, _, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if isLive {
+		jsonErr(w, "That database is a live database.  It doesn't support tags.", http.StatusBadRequest)
+		return
+	}
+
 	// Retrieve the tags
 	tags, err := com.GetTags(dbOwner, dbFolder, dbName)
 	if err != nil {
@@ -660,9 +1108,10 @@ func tagsHandler(w http.ResponseWriter, r *http.Request) {
 //   * "sourceurl" (optional) is the URL to the reference source of the data
 //   * "lastmodified" (optional) is a datestamp in RFC3339 format
 //   * "licence" (optional) is an identifier for a license that's "in the system"
-//   * "public" (optional) is whether or not the database should be public.  True means "public", false means "not public"
+//   * "live" (optional) is a boolean string ("true", "false") indicating whether this upload is a live database
+//   * "public" (optional) is whether the database should be public.  True means "public", false means "not public"
 //   * "commit" (ignored for new databases, required for existing ones) is the commit ID this new database revision
-//      should be appended to.  For new databases it's not needed, but for existing databases it's required (its used to
+//      should be appended to.  For new databases it's not needed, but for existing databases it's required (it's used to
 //      detect out of date / conflicting uploads)
 func uploadHandler(w http.ResponseWriter, r *http.Request) {
 	// Authenticate the request
@@ -710,14 +1159,125 @@ func uploadHandler(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
+	// Get "live" boolean value, if provided by the caller
+	var live bool
+	live, err = com.GetFormLive(r)
+	if err != nil {
+		jsonErr(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
 	// Process the upload
 	var httpStatus int
 	var x map[string]string
 	dbOwner := loggedInUser // We always use the API key / cert owner as the database owner for uploads
-	x, httpStatus, err = com.UploadResponse(w, r, loggedInUser, dbOwner, dbName, commitID, "api")
-	if err != nil {
-		jsonErr(w, err.Error(), httpStatus)
-		return
+	if !live {
+		x, httpStatus, err = com.UploadResponse(w, r, loggedInUser, dbOwner, dbName, commitID, "api")
+		if err != nil {
+			jsonErr(w, err.Error(), httpStatus)
+			return
+		}
+	} else {
+		// FIXME: The code below is grabbed from com.UploadResponse(), and is also very similar to the code in the
+		//        webui uploadDataHandler().  May be able to refactor them.
+
+		// Grab the uploaded file and form variables
+		var tempFile multipart.File
+		var handler *multipart.FileHeader
+		tempFile, handler, err = r.FormFile("file")
+		if err != nil && err.Error() != "http: no such file" {
+			log.Printf("Uploading file failed: %v", err)
+			jsonErr(w, fmt.Sprintf("Something went wrong when grabbing the file data: '%s'", err.Error()), http.StatusBadRequest)
+			return
+		}
+		if err != nil {
+			if err.Error() == "http: no such file" {
+				// Check for a 'file1' FormFile too, as some clients can't use 'file' (without a number) due to a design bug
+				tempFile, handler, err = r.FormFile("file1")
+				if err != nil {
+					log.Printf("Uploading file failed: %v", err)
+					jsonErr(w, fmt.Sprintf("Something went wrong when grabbing the file data: '%s'", err.Error()), http.StatusBadRequest)
+					return
+				}
+			}
+		}
+		defer tempFile.Close()
+
+		// If no database name was passed as a function argument, use the name given in the upload itself
+		if dbName == "" {
+			dbName = handler.Filename
+		}
+
+		// Validate the database name
+		err = com.ValidateDB(dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Check if the database exists already
+		exists, err := com.CheckDBExists(loggedInUser, "/", dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// If the upload is a live database, but the database already exists, then abort the upload
+		// TODO: Consider if we want the existing "force" flag to be useful here, to potentially allow overwriting a
+		//       live database
+		if exists && live {
+			jsonErr(w, "You're uploading a live database, but the same database name already exists.  "+
+				"Delete that one first if you really want to overwrite it", http.StatusConflict)
+			return
+		}
+
+		// Write the incoming database to a temporary file on disk, and sanity check it
+		dbFolder := "/"
+		var numBytes int64
+		var tempDB *os.File
+		numBytes, tempDB, _, _, err = com.WriteDBtoDisk(loggedInUser, dbOwner, dbFolder, dbName, tempFile)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer os.Remove(tempDB.Name())
+
+		// Rewind the internal cursor in the temporary file back to the start again
+		var newOffset int64
+		newOffset, err = tempDB.Seek(0, 0)
+		if err != nil {
+			log.Printf("Seeking on the temporary file (2nd time) failed: %s", err)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if newOffset != 0 {
+			jsonErr(w, "Seeking to start of temporary database file didn't work", http.StatusInternalServerError)
+			return
+		}
+
+		// Store the database in Minio
+		err = com.LiveStoreDatabaseMinio(tempDB, dbOwner, dbName, numBytes)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Log the successful database upload
+		log.Printf("API Server: Username '%s' uploaded LIVE database '%s/%s', bytes: %v", loggedInUser,
+			com.SanitiseLogString(dbOwner), com.SanitiseLogString(dbName), numBytes)
+
+		// Send a request to the AMQP backend to set up the database there, ready for querying
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			log.Println(err)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Upload was successful, so we construct a fake commit ID then return a success message to the user
+		x = make(map[string]string)
+		x["commit_id"] = ""
+		x["url"] = fmt.Sprintf("/%s", dbOwner)
 	}
 
 	// Construct the response message
@@ -753,22 +1313,95 @@ func uploadHandler(w http.ResponseWriter, r *http.Request) {
 //   * "dbowner" is the owner of the database being queried
 //   * "dbname" is the name of the database being queried
 func viewsHandler(w http.ResponseWriter, r *http.Request) {
-	// Do auth check, grab request info, open the database
-	sdb, httpStatus, err := collectInfoAndOpen(w, r)
+	// Do auth check, grab request info
+	loggedInUser, dbOwner, dbName, _, httpStatus, err := collectInfo(w, r)
 	if err != nil {
 		jsonErr(w, err.Error(), httpStatus)
 		return
 	}
-	defer sdb.Close()
+	dbFolder := "/"
 
-	// Retrieve the list of views
-	views, err := com.Views(sdb)
+	// Check if the database is a live database, and get the node/queue to send the request to
+	isLive, liveNode, err := com.CheckDBLive(dbOwner, dbFolder, dbName)
 	if err != nil {
 		jsonErr(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	// If a live database has been uploaded but doesn't have a live node handling its requests, then create one
+	if isLive && liveNode == "" {
+		// Send a request to the AMQP backend to setup a node with the database
+		err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// If it's a standard database, process it locally.  Else send the query to our AMQP backend
+	var views []string
+	if !isLive {
+		// Get Minio bucket and object id for the SQLite file
+		bucket, id, _, err := com.MinioLocation(dbOwner, dbFolder, dbName, "", loggedInUser)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Sanity check
+		if id == "" {
+			// The requested database wasn't found, or the user doesn't have permission to access it
+			jsonErr(w, "Requested database not found", http.StatusNotFound)
+			return
+		}
+
+		// Retrieve the database from Minio, then open it
+		var sdb *sqlite.Conn
+		sdb, err = com.OpenSQLiteDatabase(bucket, id)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer sdb.Close()
+
+		// Retrieve the list of views
+		views, err = com.Views(sdb)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Send the columns request to our AMQP backend
+		var rawResponse []byte
+		rawResponse, err = com.MQSendRequest(com.AmqpChan, liveNode, "views", loggedInUser, dbOwner, dbName, "")
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+
+		// Decode the response
+		var resp com.LiveDBViewsResponse
+		err = json.Unmarshal(rawResponse, &resp)
+		if err != nil {
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			log.Println(err)
+			return
+		}
+		if resp.Error != "" {
+			err = errors.New(resp.Error)
+			jsonErr(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if resp.Node == "" {
+			log.Printf("In API (Live) viewsHandler().  A node responded, but didn't identify itself.")
+			return
+		}
+		views = resp.Views
+	}
+
 	// Return the results
+	sort.Strings(views)
 	jsonData, err := json.MarshalIndent(views, "", "  ")
 	if err != nil {
 		log.Printf("Error when JSON marshalling returned data in viewsHandler(): %v\n", err)
diff --git a/api/main.go b/api/main.go
index ae22a7536..180cd02fb 100644
--- a/api/main.go
+++ b/api/main.go
@@ -1,5 +1,21 @@
 package main
 
+// TODO: API functions that still need updating for Live databases
+//         * diff - already updated to just return an error for live databases.  needs testing though
+//         * download - Not done yet.  Maybe use the SQLite backup API (https://www.sqlite.org/backup.html) or
+//                      VACUUM INTO command to create a temp copy to send to the user?
+//                      Maybe do that backup into Minio, then send from there?  Probably need to experiment a bit.
+
+// FIXME: Update the documented Upload() function return values on the API doc page.  Currently it talks about
+//        returning the commit ID for the upload.  We'll probably return that field with a blank value for live
+//        databases though.  TBD.
+
+// FIXME: We should probably add a "changelog.html" page to the API server, and record the differences between each
+//        version of the API we release
+
+// FIXME: After the API and webui pieces are done, figure out how the DB4S end
+//        point and dio should be updated to use live databases too
+
 import (
 	"crypto/tls"
 	"crypto/x509"
@@ -64,6 +80,12 @@ func main() {
 		log.Fatalf(err.Error())
 	}
 
+	// Connect to MQ server
+	com.AmqpChan, err = com.ConnectMQ("api server")
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	// Connect to the Memcached server
 	err = com.ConnectCache()
 	if err != nil {
diff --git a/api/templates/head.html b/api/templates/head.html
deleted file mode 100644
index 0873c971b..000000000
--- a/api/templates/head.html
+++ /dev/null
@@ -1,7 +0,0 @@
-[[ define "head" ]]
-<head>
-    <meta charset="UTF-8">
-    <title>DBHub.io API Documentation</title>
-    <link href="//netdna.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
-</head>
-[[ end ]]
\ No newline at end of file
diff --git a/api/templates/root.html b/api/templates/root.html
index 5f92f8435..43adf7f91 100644
--- a/api/templates/root.html
+++ b/api/templates/root.html
@@ -1,7 +1,11 @@
 [[ define "docs" ]]
 <!doctype html>
 <html>
-[[ template "head" . ]]
+<head>
+    <meta charset="UTF-8">
+    <title>DBHub.io API Documentation</title>
+    <link href="//netdna.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
+</head>
 <body>
 <style>
     * {
@@ -54,7 +58,7 @@
         <div class="col-md-12"><a href="https://dbhub.io"><h1>DBHub API (in early development)</h1></a></div>
     </div>
     <div class="row">
-        <div class="col-md-12 version">API version 0.1, last modified 2020-08-14</div>
+        <div class="col-md-12 version">API version 0.2, last modified 2023-03-20</div>
     </div>
     <div class="panel panel-primary" id="note">
         <div class="panel-heading heading">Note</div>
@@ -551,9 +555,23 @@
                 <div class="col-md-2 heading pad">Parameters (POST)</div>
                 <div class="col-md-10"></div>
             </div>
+            <div class="row indent returnhdr">
+                <div class="col-md-2">Name</div>
+                <div class="col-md-1">Type</div>
+                <div class="col-md-2">Optional</div>
+                <div class="col-md-7">Description</div>
+            </div>
             <div class="row indent">
                 <div class="col-md-2 paramname">apikey</div>
-                <div class="col-md-10">Your API key.  These can be generated in your <a href="https://[[ .ServerName ]]/pref">Settings</a> page, when logged in</div>
+                <div class="col-md-1 type">string</div>
+                <div class="col-md-2">Required</div>
+                <div class="col-md-7">Your API key.  These can be generated in your <a href="https://[[ .ServerName ]]/pref">Settings</a> page, when logged in</div>
+            </div>
+            <div class="row indent">
+                <div class="col-md-2 paramname" style="color: #a01e1a">live</div>
+                <div class="col-md-1 type" style="color: #a01e1a">boolean</div>
+                <div class="col-md-2" style="color: #a01e1a">Optional</div>
+                <div class="col-md-7" style="color: #a01e1a"><div style="font-style: italic; font-weight: bold">NEW in API version 0.2</div><div>A boolean string ("true", "false") to switch between returning the list of standard databases, and the list of live databases</div><div>NOTE: This "live" parameter is experimental, and may change</div></div>
             </div>
             <div class="row">
                 <div class="col-md-2 heading pad">Return values (JSON)</div>
@@ -1527,6 +1545,12 @@
                 <div class="col-md-2">Optional</div>
                 <div class="col-md-7">The sha256 (a unique identifier) of the licence for the database (up to this commit)</div>
             </div>
+            <div class="row indent">
+                <div class="col-md-2 paramname" style="color: #a01e1a">live</div>
+                <div class="col-md-1 type" style="color: #a01e1a">boolean</div>
+                <div class="col-md-2" style="color: #a01e1a">Optional</div>
+                <div class="col-md-7" style="color: #a01e1a"><div style="font-style: italic; font-weight: bold">NEW in API version 0.2</div><div>A boolean string ("true", "false") indicating whether this upload is a live database</div><div>NOTE: This "live" parameter is experimental, and may change</div></div>
+            </div>
             <div class="row indent">
                 <div class="col-md-2 paramname">otherparents</div>
                 <div class="col-md-1 type">string</div>
diff --git a/common/cypress.go b/common/cypress.go
index 0a5b6180b..e73a4ac6c 100644
--- a/common/cypress.go
+++ b/common/cypress.go
@@ -67,6 +67,33 @@ func CypressSeed(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// *** Add a test LIVE SQLite database (start) ***
+
+	// Open the live database file
+	liveDB1, err := os.Open(path.Join(Conf.Web.BaseDir, "cypress", "test_data", "Join Testing with index.sqlite"))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer liveDB1.Close()
+
+	// Store the live database in Minio
+	err = LiveStoreDatabaseMinio(liveDB1, "default", "Join Testing with index.sqlite", 16384)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Send the live database file to our AMQP backend for setup
+	err = LiveCreateDB(AmqpChan, "default", "Join Testing with index.sqlite")
+	if err != nil {
+		log.Println(err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// *** Add a test LIVE SQLite database (end) ***
+
 	// Add some test users
 	err = AddUser("auth0first", "first", RandomString(32), fmt.Sprintf("first@%s", serverName[0]), "First test user", "")
 	if err != nil {
diff --git a/common/diff.go b/common/diff.go
index c9ba0f62f..83a0ca194 100644
--- a/common/diff.go
+++ b/common/diff.go
@@ -317,7 +317,7 @@ func dataDiffForAllTableRows(sdb *sqlite.Conn, schemaName string, tableName stri
 	query += " FROM " + EscapeId(schemaName) + "." + EscapeId(tableName)
 
 	// Retrieve data and add it to the data diff object
-	_, _, data, err := SQLiteRunQuery(sdb, Internal, query, false, false)
+	_, _, data, err := SQLiteRunQuery(sdb, QuerySourceInternal, query, false, false)
 	if err != nil {
 		log.Printf("Error getting rows in dataDiffForAllTableRows(): %s\n", err)
 		return nil, err
@@ -502,7 +502,7 @@ func dataDiffForModifiedTableRows(sdb *sqlite.Conn, tableName string, merge Merg
 	// the DataDiff object.
 
 	// Retrieve data and generate a new DataDiff object for each row
-	_, _, data, err := SQLiteRunQuery(sdb, Internal, query, false, false)
+	_, _, data, err := SQLiteRunQuery(sdb, QuerySourceInternal, query, false, false)
 	if err != nil {
 		log.Printf("Error getting rows in dataDiffForModifiedTableRows(): %s\n", err)
 		return nil, err
diff --git a/common/live.go b/common/live.go
new file mode 100644
index 000000000..5b78eb626
--- /dev/null
+++ b/common/live.go
@@ -0,0 +1,536 @@
+package common
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"time"
+
+	sqlite "github.com/gwenn/gosqlite"
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+const (
+	contextTimeout = 5 * time.Second
+)
+
+var (
+	// AmqpChan is the AMQP channel handle we use for communication with our AMQP backend
+	AmqpChan *amqp.Channel
+
+	// AmqpDebug controls whether to output - via Log.Print*() functions -  useful messages during processing.  Mostly
+	// useful for development / debugging purposes
+	AmqpDebug = true
+
+	// NodeName holds the name of the current Live node
+	NodeName string
+)
+
+// LiveDBColumnsResponse holds the fields used for receiving column list responses from our AMQP backend
+type LiveDBColumnsResponse struct {
+	Node    string          `json:"node"`
+	Columns []sqlite.Column `json:"columns"`
+	Error   string          `json:"error"`
+}
+
+// LiveDBIndexesResponse holds the fields used for receiving index list responses from our AMQP backend
+type LiveDBIndexesResponse struct {
+	Node    string         `json:"node"`
+	Indexes []APIJSONIndex `json:"indexes"`
+	Error   string         `json:"error"`
+}
+
+// LiveDBErrorResponse holds just the node name and any error message used in responsed by our AMQP backend
+// It's useful for error message, and other responses where no other fields are needed
+type LiveDBErrorResponse struct {
+	Node  string `json:"node"`
+	Error string `json:"error"`
+}
+
+// LiveDBQueryResponse holds the fields used for receiving query responses from our AMQP backend
+type LiveDBQueryResponse struct {
+	Node    string          `json:"node"`
+	Results SQLiteRecordSet `json:"results"`
+	Error   string          `json:"error"`
+}
+
+// LiveDBRequest holds the fields used for sending requests to our AMQP backend
+type LiveDBRequest struct {
+	Operation      string `json:"operation"`
+	DBOwner        string `json:"dbowner"`
+	DBName         string `json:"dbname"`
+	Query          string `json:"query"`
+	RequestingUser string `json:"requesting_user"`
+}
+
+// LiveDBResponse holds the fields used for receiving (non-query) responses from our AMQP backend
+type LiveDBResponse struct {
+	Node   string `json:"node"`
+	Result string `json:"result"`
+	Error  string `json:"error"`
+}
+
+// LiveDBs is used for general purpose holding of details about live databases
+type LiveDBs struct {
+	DBOwner     string    `json:"owner_name"`
+	DBName      string    `json:"database_name"`
+	DateCreated time.Time `json:"date_created"`
+}
+
+// LiveDBTablesResponse holds the fields used for receiving table list responses from our AMQP backend
+type LiveDBTablesResponse struct {
+	Node   string   `json:"node"`
+	Tables []string `json:"tables"`
+	Error  string   `json:"error"`
+}
+
+// LiveDBViewsResponse holds the fields used for receiving view list responses from our AMQP backend
+type LiveDBViewsResponse struct {
+	Node  string   `json:"node"`
+	Views []string `json:"views"`
+	Error string   `json:"error"`
+}
+
+// CloseMQChannel closes an open AMQP channel
+func CloseMQChannel(channel *amqp.Channel) (err error) {
+	err = channel.Close()
+	return
+}
+
+// CloseMQConnection closes an open AMQP connection
+func CloseMQConnection(connection *amqp.Connection) (err error) {
+	err = connection.Close()
+	return
+}
+
+// ConnectMQ creates a connection to the backend MQ server
+func ConnectMQ(nodeName string) (channel *amqp.Channel, err error) {
+	var conn *amqp.Connection
+	conn, err = amqp.Dial(fmt.Sprintf("amqp://%s:%s@%s:%d/", Conf.MQ.Username, Conf.MQ.Password, Conf.MQ.Server, Conf.MQ.Port))
+	if err != nil {
+		return
+	}
+
+	channel, err = conn.Channel()
+	if err != nil {
+		return
+	}
+
+	// Log successful connection
+	log.Printf("'%s' connected to AMQP server: %v:%d\n", nodeName, Conf.MQ.Server, Conf.MQ.Port)
+	return
+}
+
+// LiveCreateDB requests the AMQP backend to create a new live SQLite database
+func LiveCreateDB(channel *amqp.Channel, dbOwner, dbName string) (err error) {
+	// Send the database setup request to our AMQP backend
+	var rawResponse []byte
+	rawResponse, err = MQSendRequest(channel, "create_queue", "createdb", "", dbOwner, dbName, "")
+	if err != nil {
+		return
+	}
+
+	// Decode the response
+	var resp LiveDBResponse
+	err = json.Unmarshal(rawResponse, &resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	if resp.Error != "" {
+		err = errors.New(resp.Error)
+		return
+	}
+	if resp.Node == "" {
+		err = errors.New("A node responded, but didn't identify itself. :(")
+		return
+	}
+	if resp.Result != "success" {
+		err = errors.New(fmt.Sprintf("LIVE database (%s/%s) creation apparently didn't fail, but the response didn't include a success message",
+			dbOwner, dbName))
+		return
+	}
+
+	// Update PG, so it has a record of this database existing and knows the node/queue name for querying it
+	err = LiveAddDatabasePG(dbOwner, dbName, resp.Node)
+	return
+}
+
+// LiveQueryDB sends a SQLite query to a live database on its hosting node
+func LiveQueryDB(channel *amqp.Channel, nodeName, requestingUser, dbOwner, dbName, query string) (rows SQLiteRecordSet, err error) {
+	// Send the query request to our AMQP backend
+	var rawResponse []byte
+	rawResponse, err = MQSendRequest(channel, nodeName, "query", requestingUser, dbOwner, dbName, query)
+	if err != nil {
+		return
+	}
+
+	// Decode the response
+	var resp LiveDBQueryResponse
+	err = json.Unmarshal(rawResponse, &resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	if resp.Error != "" {
+		err = errors.New(resp.Error)
+		return
+	}
+	rows = resp.Results
+	return
+}
+
+// MQColumnsResponse sends a columns list response
+func MQColumnsResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, columns []sqlite.Column, errMsg string) (err error) {
+	// Construct the response
+	resp := LiveDBColumnsResponse{
+		Node:    nodeName,
+		Columns: columns,
+		Error:   errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[COLUMNS] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQCreateDBQueue creates a queue on the MQ server for "create database" messages
+func MQCreateDBQueue(channel *amqp.Channel) (queue amqp.Queue, err error) {
+	queue, err = channel.QueueDeclare("create_queue", true, false, false, false, nil)
+	if err != nil {
+		return
+	}
+
+	// FIXME: Re-read the docs for this, and work out if this is needed
+	err = channel.Qos(1, 0, false)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// MQCreateQueryQueue creates a queue on the MQ server for sending database queries to
+func MQCreateQueryQueue(channel *amqp.Channel, nodeName string) (queue amqp.Queue, err error) {
+	queue, err = channel.QueueDeclare(nodeName, false, false, false, false, nil)
+	if err != nil {
+		return
+	}
+
+	// FIXME: Re-read the docs for this, and work out if this is needed
+	err = channel.Qos(0, 0, false)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// MQCreateResponse sends a success/failure response back
+func MQCreateResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName, result string) (err error) {
+	// Construct the response.  It's such a simple string we just create it directly instead of using json.Marshall()
+	resp := fmt.Sprintf(`{"node":"%s","dbowner":"","dbname":"","result":"%s","error":""}`, nodeName, result)
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          []byte(resp),
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[CREATE] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQErrorResponse sends an error message in response to an AMQP request
+// It is probably only useful for returning errors that occur before we've decoded the incoming AMQP
+// request to know what type it is
+func MQErrorResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, errMsg string) (err error) {
+	// Construct the query response request
+	resp := LiveDBErrorResponse{
+		Node:  nodeName,
+		Error: errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[NOT-YET-DETERMINED] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQDeleteResponse sends an error message in response to an AMQP database deletion request
+func MQDeleteResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, errMsg string) (err error) {
+	// Construct the query response request
+	resp := LiveDBErrorResponse{ // Yep, we're reusing this super basic error response instead of creating a new one
+		Node:  nodeName,
+		Error: errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[DELETE] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQIndexesResponse sends an indexes list response
+func MQIndexesResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, indexes []APIJSONIndex, errMsg string) (err error) {
+	// Construct the response
+	resp := LiveDBIndexesResponse{
+		Node:    nodeName,
+		Indexes: indexes,
+		Error:   errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[INDEXES] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQQueryResponse sends a successful query response back
+func MQQueryResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, results SQLiteRecordSet, errMsg string) (err error) {
+	// Construct the query response request
+	resp := LiveDBQueryResponse{
+		Node:    nodeName,
+		Results: results,
+		Error:   errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[QUERY] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+func MQSendRequest(channel *amqp.Channel, queue, operation, requestingUser, dbOwner, dbName, query string) (result []byte, err error) {
+	// Create a temporary AMQP queue for receiving the response
+	var q amqp.Queue
+	q, err = channel.QueueDeclare("", false, false, true, false, nil)
+	if err != nil {
+		return
+	}
+
+	// Construct the request
+	bar := LiveDBRequest{
+		Operation:      operation,
+		DBOwner:        dbOwner,
+		DBName:         dbName,
+		Query:          query,
+		RequestingUser: requestingUser,
+	}
+	var z []byte
+	z, err = json.Marshal(bar)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the request via AMQP
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	corrID := RandomString(32)
+	err = channel.PublishWithContext(ctx, "", queue, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: corrID,
+			ReplyTo:       q.Name,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Start processing messages from the AMQP response queue
+	msgs, err := channel.Consume(q.Name, "", true, false, false, false, nil)
+	if err != nil {
+		return
+	}
+
+	// Wait for, then extract the response.  Without json unmarshalling it yet
+	for d := range msgs {
+		if corrID == d.CorrelationId {
+			result = d.Body
+			break
+		}
+	}
+
+	// Delete the temporary queue
+	_, err = channel.QueueDelete(q.Name, false, false, false)
+	if err != nil {
+		log.Println(err)
+	}
+	return
+}
+
+// MQTablesResponse sends a tables list response to an AMQP caller
+func MQTablesResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, tables []string, errMsg string) (err error) {
+	// Construct the response
+	resp := LiveDBTablesResponse{
+		Node:   nodeName,
+		Tables: tables,
+		Error:  errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[TABLES] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
+
+// MQViewsResponse sends a views list response to an AMQP caller
+func MQViewsResponse(msg amqp.Delivery, channel *amqp.Channel, nodeName string, views []string, errMsg string) (err error) {
+	// Construct the response
+	resp := LiveDBViewsResponse{
+		Node:  nodeName,
+		Views: views,
+		Error: errMsg,
+	}
+	var z []byte
+	z, err = json.Marshal(resp)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Send the message
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+	err = channel.PublishWithContext(ctx, "", msg.ReplyTo, false, false,
+		amqp.Publishing{
+			ContentType:   "text/json",
+			CorrelationId: msg.CorrelationId,
+			Body:          z,
+		})
+	if err != nil {
+		log.Println(err)
+	}
+	msg.Ack(false)
+	if AmqpDebug {
+		log.Printf("[VIEWS] Live node '%s' responded with ACK to message with correlationID: '%s', msg.ReplyTo: '%s'", nodeName, msg.CorrelationId, msg.ReplyTo)
+	}
+	return
+}
diff --git a/common/minio.go b/common/minio.go
index 9a98b0212..8ba573faa 100644
--- a/common/minio.go
+++ b/common/minio.go
@@ -30,6 +30,104 @@ func ConnectMinio() (err error) {
 	return nil
 }
 
+// LiveRetrieveDatabaseMinio retrieves a live SQLite database from Minio, and places it on the local filesystem
+func LiveRetrieveDatabaseMinio(baseDir, dbOwner, dbName string) (dbPath string, err error) {
+	// Create the directory to hold the live database
+	// NOTE: It's probably best to use both dbOwner and dbName in the path, calling the database something like
+	//       "live.sqlite".  That should avoid any potential conflicts with creative database names having
+	//       .wal (or similar) file extension, which could otherwise happen if we put all the databases from
+	//       a given user into one directory
+	dbDir := filepath.Join(baseDir, dbOwner, dbName)
+	err = os.MkdirAll(dbDir, 0750)
+	if err != nil {
+		return
+	}
+
+	// Get a handle from Minio for the database object
+	var userDB *minio.Object
+	userDB, err = MinioHandle(fmt.Sprintf("live-%s", dbOwner), dbName)
+	if err != nil {
+		return
+	}
+
+	// Close the object handle when this function finishes
+	defer MinioHandleClose(userDB)
+
+	// Save the database file locally
+	var f *os.File
+	var bytesWritten int64
+	dbPath = filepath.Join(dbDir, "live.sqlite")
+	f, err = os.OpenFile(dbPath, os.O_CREATE|os.O_WRONLY, 0750)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	bytesWritten, err = io.Copy(f, userDB)
+	if err != nil {
+		return
+	}
+	if bytesWritten == 0 {
+		log.Printf("Error! 0 bytes written to the new SQLite database file: %s\n", dbPath)
+		err = errors.New("Internal server error")
+		return
+	}
+
+	if AmqpDebug {
+		log.Printf("Live node '%s': Database file '%s/%s' written to filesystem at: '%s'",
+			NodeName, dbOwner, dbName, dbPath)
+	}
+	return
+}
+
+// LiveStoreDatabaseMinio stores a live SQLite database in Minio
+func LiveStoreDatabaseMinio(db *os.File, dbOwner, dbName string, dbSize int64) (err error) {
+	// If a Minio bucket with the desired name doesn't already exist, create it
+	var found bool
+	var bkt = fmt.Sprintf("live-%s", dbOwner)
+	found, err = minioClient.BucketExists(bkt)
+	if err != nil {
+		return err
+	}
+	if !found {
+		err := minioClient.MakeBucket(bkt, "us-east-1")
+		if err != nil {
+			return err
+		}
+	}
+
+	// Store the SQLite database file in Minio
+	numBytes, err := minioClient.PutObject(bkt, dbName, db, dbSize, minio.PutObjectOptions{ContentType: "application/x-sqlite3"})
+	if err != nil {
+		return err
+	}
+
+	// Sanity check.  Make sure the # of bytes written is equal to the size of the database we were given
+	if dbSize != numBytes {
+		err = errors.New(fmt.Sprintf("Something went wrong storing the database file.  dbSize = %v, numBytes = %v",
+			dbSize, numBytes))
+		return err
+	}
+
+	if AmqpDebug {
+		log.Printf("Added Minio LIVE database object '%s/%s', using bucket '%s' and id '%s'", dbOwner, dbName, bkt, dbName)
+	}
+	return
+}
+
+// MinioDeleteDatabase deletes a database file from Minio
+func MinioDeleteDatabase(source, dbOwner, dbName, bucket, id string) (err error) {
+	err = minioClient.RemoveObject(bucket, id)
+	if err != nil {
+		return
+	}
+
+	if AmqpDebug {
+		log.Printf("[DELETE] '%s' removed Minio database object '%s/%s', using bucket '%s' and id '%s'",
+			source, dbOwner, dbName, bucket, id)
+	}
+	return
+}
+
 // MinioHandle gets a handle from Minio for a SQLite database object
 func MinioHandle(bucket, id string) (*minio.Object, error) {
 	userDB, err := minioClient.GetObject(bucket, id, minio.GetObjectOptions{})
@@ -138,13 +236,13 @@ func StoreDatabaseFile(db *os.File, sha string, dbSize int64) error {
 	// Store the SQLite database file in Minio
 	numBytes, err := minioClient.PutObject(bkt, id, db, dbSize, minio.PutObjectOptions{ContentType: "application/x-sqlite3"})
 	if err != nil {
-		log.Printf("Storing file in Minio failed: %v\n", err)
+		log.Printf("Storing file in Minio failed: %v", err)
 		return err
 	}
 
 	// Sanity check.  Make sure the # of bytes written is equal to the size of the buffer we were given
 	if dbSize != numBytes {
-		log.Printf("Something went wrong storing the database file.  dbSize = %v, numBytes = %v\n", dbSize,
+		log.Printf("Something went wrong storing the database file.  dbSize = %v, numBytes = %v", dbSize,
 			numBytes)
 		return err
 	}
diff --git a/common/postgresql.go b/common/postgresql.go
index 592d8791e..4b88543be 100644
--- a/common/postgresql.go
+++ b/common/postgresql.go
@@ -157,6 +157,32 @@ func CheckDBExists(dbOwner, dbFolder, dbName string) (bool, error) {
 	return dbCount != 0, nil
 }
 
+// CheckDBLive checks if the given database is a live database
+func CheckDBLive(dbOwner, dbFolder, dbName string) (isLive bool, liveNode string, err error) {
+	// Query matching databases
+	dbQuery := `
+		SELECT live_db, live_node
+		FROM sqlite_databases
+		WHERE user_id = (
+				SELECT user_id
+				FROM users
+				WHERE lower(user_name) = lower($1)
+			)
+			AND folder = $2
+			AND db_name = $3
+			AND is_deleted = false
+		LIMIT 1`
+	var n pgx.NullString
+	err = pdb.QueryRow(dbQuery, dbOwner, dbFolder, dbName).Scan(&isLive, &n)
+	if err != nil {
+		return false, "", err
+	}
+	if n.Valid {
+		liveNode = n.String
+	}
+	return
+}
+
 // CheckDBPermissions checks if a database exists and can be accessed by the given user.
 // If an error occurred, the true/false value should be ignored, as only the error value is valid
 func CheckDBPermissions(loggedInUser, dbOwner, dbFolder, dbName string, writeAccess bool) (bool, error) {
@@ -813,6 +839,12 @@ func DeleteDatabase(dbOwner, dbFolder, dbName string) error {
 	// TODO: At some point we'll need to figure out a garbage collection approach to remove databases from Minio which
 	// TODO  are no longer pointed to by anything
 
+	// Is this a live database
+	isLive, _, err := CheckDBLive(dbOwner, dbFolder, dbName)
+	if err != nil {
+		return err
+	}
+
 	// Begin a transaction
 	tx, err := pdb.Begin()
 	if err != nil {
@@ -845,7 +877,7 @@ func DeleteDatabase(dbOwner, dbFolder, dbName string) error {
 		return err
 	}
 	if numForks == 0 {
-		// * There are no forks for this database, so we just remove it's entry from sqlite_databases.  The 'ON DELETE
+		// * There are no forks for this database, so we just remove its entry from sqlite_databases.  The 'ON DELETE
 		// CASCADE' definition for the database_stars table/field should automatically remove any references to the
 		// now deleted entry *
 
@@ -877,7 +909,7 @@ func DeleteDatabase(dbOwner, dbFolder, dbName string) error {
 				SanitiseLogString(dbFolder), SanitiseLogString(dbName), err)
 			return err
 		}
-		if numRows := commandTag.RowsAffected(); numRows != 1 {
+		if numRows := commandTag.RowsAffected(); numRows != 1 && !isLive { // Skip this check when deleting live databases
 			log.Printf("Wrong number of rows (%v) affected (spot 1) when updating fork count for database '%s%s%s'\n",
 				numRows, SanitiseLogString(dbOwner), SanitiseLogString(dbFolder), SanitiseLogString(dbName))
 		}
@@ -2518,6 +2550,63 @@ func IncrementDownloadCount(dbOwner, dbFolder, dbName string) error {
 	return nil
 }
 
+// LiveAddDatabasePG adds the details for a live database to PostgreSQL
+func LiveAddDatabasePG(dbOwner, dbName, liveNode string) (err error) {
+	var commandTag pgx.CommandTag
+	dbQuery := `
+		WITH root AS (
+			SELECT nextval('sqlite_databases_db_id_seq') AS val
+		)
+		INSERT INTO sqlite_databases (user_id, db_id, folder, db_name, live_db, live_node)
+		SELECT (
+			SELECT user_id
+			FROM users
+			WHERE lower(user_name) = lower($1)), (SELECT val FROM root), '/', $2, true, $3`
+	commandTag, err = pdb.Exec(dbQuery, dbOwner, dbName, liveNode)
+	if err != nil {
+		log.Printf("Storing LIVE database '%s/%s' failed: %v\n", SanitiseLogString(dbOwner), SanitiseLogString(dbName), err)
+		return err
+	}
+	if numRows := commandTag.RowsAffected(); numRows != 1 {
+		log.Printf("Wrong number of rows (%v) affected while storing LIVE database '%s/%s'\n", numRows,
+			SanitiseLogString(dbOwner), SanitiseLogString(dbName))
+	}
+	return nil
+}
+
+// LiveDatabasesOnNode returns the list of databases that are on a specific live backend node
+func LiveDatabasesOnNode(nodeName string) (err error) {
+	return
+}
+
+// LiveUserDBs returns the list of live databases owned by the user
+func LiveUserDBs(dbOwner string) (list []DBInfo, err error) {
+	dbQuery := `
+		SELECT db_name, date_created
+		FROM sqlite_databases AS db, users
+		WHERE users.user_id = db.user_id
+			AND lower(users.user_name) = lower($1)
+			AND is_deleted = false
+			AND live_db = true
+		ORDER BY date_created DESC`
+	rows, err := pdb.Query(dbQuery, dbOwner)
+	if err != nil {
+		log.Printf("Database query failed: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var oneRow DBInfo
+		err = rows.Scan(&oneRow.Database, &oneRow.DateCreated)
+		if err != nil {
+			log.Printf("Error when retrieving list of live databases for user '%s': %v\n", dbOwner, err)
+			return nil, err
+		}
+		list = append(list, oneRow)
+	}
+	return
+}
+
 // LogDB4SConnect creates a DB4S default browse list entry
 func LogDB4SConnect(userAcc, ipAddr, userAgent string, downloadDate time.Time) error {
 	if Conf.DB4S.Debug {
@@ -3703,7 +3792,8 @@ func StoreCommits(dbOwner, dbFolder, dbName string, commitList map[string]Commit
 
 // StoreDatabase stores database details in PostgreSQL, and the database data itself in Minio
 func StoreDatabase(dbOwner, dbFolder, dbName string, branches map[string]BranchEntry, c CommitEntry, pub bool,
-	buf *os.File, sha string, dbSize int64, oneLineDesc, fullDesc string, createDefBranch bool, branchName, sourceURL string) error {
+	buf *os.File, sha string, dbSize int64, oneLineDesc, fullDesc string, createDefBranch bool, branchName,
+	sourceURL string) error {
 	// Store the database file
 	err := StoreDatabaseFile(buf, sha, dbSize)
 	if err != nil {
@@ -4627,7 +4717,8 @@ func UserDBs(userName string, public AccessType) (list []DBInfo, err error) {
 				db.download_count, db.page_views
 			FROM sqlite_databases AS db, default_commits
 			WHERE db.db_id = default_commits.db_id
-				AND db.is_deleted = false`
+				AND db.is_deleted = false
+				AND db.live_db = false`
 	switch public {
 	case DB_PUBLIC:
 		// Only public databases
@@ -4691,7 +4782,7 @@ func UserDBs(userName string, public AccessType) (list []DBInfo, err error) {
 
 	// Get fork count for each of the databases
 	for i, j := range list {
-		// Retrieve latest fork count
+		// Retrieve the latest fork count
 		dbQuery = `
 			WITH u AS (
 				SELECT user_id
diff --git a/common/sqlite.go b/common/sqlite.go
index 8216b78ef..6db7f674b 100644
--- a/common/sqlite.go
+++ b/common/sqlite.go
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"os"
+	"path/filepath"
 	"reflect"
 	"sort"
 	"strconv"
@@ -198,6 +200,27 @@ func init() {
 	}
 }
 
+// AuthorizerLive is a SQLite authorizer callback intended to allow almost anything.  Except for loading extensions,
+// and running pragmas.
+func AuthorizerLive(d interface{}, action sqlite.Action, tableName, funcName, dbName, triggerName string) sqlite.Auth {
+	switch action {
+	case sqlite.Pragma:
+		// The "index_info"  and "table_info" Pragmas are allowed, as they're used by SQLite internally for things we need
+		if tableName == "index_info" || tableName == "table_info" {
+			return sqlite.AuthOk
+		}
+		return sqlite.AuthDeny
+	case sqlite.Function:
+		if funcName == "load_extension" {
+			// Extension loading is disabled (at least for now)
+			return sqlite.AuthDeny
+		}
+	}
+
+	// All other action types, functions, etc are allowed
+	return sqlite.AuthOk
+}
+
 // AuthorizerSelect is a SQLite authorizer callback which only allows SELECT queries and their needed
 // sub-operations to run.
 func AuthorizerSelect(d interface{}, action sqlite.Action, tableName, funcName, dbName, triggerName string) sqlite.Auth {
@@ -236,29 +259,29 @@ func AuthorizerSelect(d interface{}, action sqlite.Action, tableName, funcName,
 }
 
 // GetSQLiteRowCount returns the number of rows in a SQLite table.
-func GetSQLiteRowCount(sdb *sqlite.Conn, dbTable string) (int, error) {
+func GetSQLiteRowCount(sdb *sqlite.Conn, dbTable string) (rowCount int, err error) {
 	dbQuery := `SELECT count(*) FROM "` + dbTable + `"`
-	var rowCount int
-	err := sdb.OneValue(dbQuery, &rowCount)
+	err = sdb.OneValue(dbQuery, &rowCount)
 	if err != nil {
 		log.Printf("Error occurred when counting total rows for table '%s'.  Error: %s\n", SanitiseLogString(dbTable), err)
 		return 0, errors.New("Database query failure")
 	}
-	return rowCount, nil
+	return
 }
 
 // OpenSQLiteDatabase retrieves a SQLite database from Minio, opens it, then returns the connection handle.
-func OpenSQLiteDatabase(bucket, id string) (*sqlite.Conn, error) {
+func OpenSQLiteDatabase(bucket, id string) (sdb *sqlite.Conn, err error) {
 	// Retrieve database file from Minio, using cached version if it's already there
-	newDB, err := RetrieveDatabaseFile(bucket, id)
+	var newDB string
+	newDB, err = RetrieveDatabaseFile(bucket, id)
 	if err != nil {
-		return nil, err
+		return
 	}
 
 	// Open database
 	// NOTE - OpenFullMutex seems like the right thing for ensuring multiple connections to a database file don't
 	// screw things up, but it wouldn't be a bad idea to keep it in mind if weirdness shows up
-	sdb, err := sqlite.Open(newDB, sqlite.OpenReadWrite|sqlite.OpenFullMutex)
+	sdb, err = sqlite.Open(newDB, sqlite.OpenReadWrite|sqlite.OpenFullMutex)
 	if err != nil {
 		log.Printf("Couldn't open database: %s", err)
 		return nil, errors.New("Internal server error")
@@ -266,9 +289,9 @@ func OpenSQLiteDatabase(bucket, id string) (*sqlite.Conn, error) {
 	err = sdb.EnableExtendedResultCodes(true)
 	if err != nil {
 		log.Printf("Couldn't enable extended result codes! Error: %v\n", err.Error())
-		return nil, err
+		return
 	}
-	return sdb, nil
+	return
 }
 
 // OpenSQLiteDatabaseDefensive is similar to OpenSQLiteDatabase(), but opens the database Read Only and implements
@@ -433,6 +456,159 @@ func OpenSQLiteDatabaseDefensive(w http.ResponseWriter, r *http.Request, dbOwner
 	return sdb, nil
 }
 
+// OpenSQLiteDatabaseLive is similar to OpenSQLiteDatabase(), but opens the a live SQLite database and implements
+// the recommended defensive precautions for potentially malicious user provided SQL
+// queries: https://www.sqlite.org/security.html
+func OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName string) (sdb *sqlite.Conn, err error) {
+	dbPath := filepath.Join(baseDir, dbOwner, dbName, "live.sqlite")
+	if _, err = os.Stat(dbPath); err != nil {
+		return
+	}
+
+	// Open database
+	// NOTE - OpenFullMutex seems like the right thing for ensuring multiple connections to a database file don't
+	// screw things up, but it wouldn't be a bad idea to keep it in mind if weirdness shows up
+	sdb, err = sqlite.Open(dbPath, sqlite.OpenReadWrite|sqlite.OpenFullMutex)
+	if err != nil {
+		log.Printf("Couldn't open LIVE database: %s", err)
+		return
+	}
+	if err = sdb.EnableExtendedResultCodes(true); err != nil {
+		log.Printf("Couldn't enable extended result codes for LIVE database query! Error: %v\n", err.Error())
+		return
+	}
+
+	// Enable the defensive flag
+	var enabled bool
+	if enabled, err = sdb.EnableDefensive(true); !enabled || err != nil {
+		log.Printf("Couldn't enable the defensive flag for LIVE database query: %v\n", err)
+		return
+	}
+
+	// Verify the defensive flag was enabled
+	if enabled, err = sdb.IsDefensiveEnabled(); !enabled || err != nil {
+		log.Printf("The defensive flag wasn't enabled for LIVE database query after all: %v\n", err)
+		return
+	}
+
+	// Turn off the trusted schema flag
+	if enabled, err = sdb.EnableTrustedSchema(false); enabled || err != nil {
+		log.Printf("Couldn't disable the trusted schema flag for LIVE database query: %v\n", err)
+		return
+	}
+
+	// Verify the trusted schema flag was turned off
+	if enabled, err = sdb.IsTrustedSchema(); enabled || err != nil {
+		log.Printf("The trusted schema flag wasn't disabled for LIVE database query after all: %v\n", err)
+		return
+	}
+
+	// Adjust limits for the SQLite connection
+	var newLimits = []struct {
+		name sqlite.Limit
+		val  int32
+	}{
+		{
+			name: sqlite.LimitLength,
+			val:  1000000, // 1,000,000
+		},
+		{
+			name: sqlite.LimitSQLLength,
+			val:  100000, // 100,000
+		},
+		{
+			name: sqlite.LimitColumn,
+			val:  100,
+		},
+		{
+			name: sqlite.LimitExprDepth,
+			val:  10,
+		},
+		{
+			name: sqlite.LimitCompoundSelect,
+			val:  3,
+		},
+		{
+			name: sqlite.LimitVdbeOp,
+			val:  25000,
+		},
+		{
+			name: sqlite.LimitFunctionArg,
+			val:  8,
+		},
+		{
+			name: sqlite.LimitAttached,
+			val:  0,
+		},
+		{
+			name: sqlite.LimitLikePatternLength,
+			val:  50,
+		},
+		{
+			name: sqlite.LimitVariableNumber,
+			val:  10,
+		},
+		{
+			name: sqlite.LimitTriggerLength,
+			val:  10,
+		},
+	}
+	for _, j := range newLimits {
+		sdb.SetLimit(j.name, j.val)
+		if sdb.Limit(j.name) != j.val {
+			err = fmt.Errorf("Was not able to set SQLite limit '%v' to desired value for LIVE database query", j.name)
+			return
+		}
+	}
+
+	// FIXME: There's new info in the SQLite "security" page, with some new things to potentially do: https://www.sqlite.org/security.html
+	//          * Disable triggers
+	// FIXME: Whatever improvements are made here, should probably also go into OpenSQLiteDatabaseDefensive()
+	// Turn on cell size checking
+	err = sdb.Exec("PRAGMA cell_size_check=ON")
+	if err != nil {
+		log.Printf("Error when running 'PRAGMA cell_size_check=on' on the LIVE database: %s", err)
+		return
+	}
+
+	// Turn off mmap
+	var ok bool
+	var results []string
+	err = sdb.Select("PRAGMA mmap_size=0", func(s *sqlite.Stmt) error {
+		// Retrieve a row from the pragma result
+		var a string
+		if err = s.Scan(&a); err != nil {
+			// Error when reading the row, so return failure
+			ok = false
+			return err
+		}
+
+		// If the returned row was the value 0, then we regard the change as successfully applied.  Any other return
+		// value is a failure
+		switch a {
+		case "0":
+			ok = true
+		default:
+			ok = false
+			results = append(results, a)
+		}
+		return nil
+	})
+
+	// Check for a failure
+	if !ok || err != nil {
+		log.Printf("Error when disabling mmap on the LIVE database: %s\n", err)
+		return
+	}
+
+	// Set a SQLite authorizer which only disallows pragma statements and the "load_extension" function
+	err = sdb.SetAuthorizer(AuthorizerLive, "SELECT authorizer")
+	if err != nil {
+		return
+	}
+	return sdb, nil
+}
+
 // ReadSQLiteDB reads up to maxRows number of rows from a given SQLite database table.  If maxRows < 0 (eg -1), then
 // read all rows.
 func ReadSQLiteDB(sdb *sqlite.Conn, dbTable, sortCol, sortDir string, maxRows, rowOffset int) (SQLiteRecordSet, error) {
@@ -536,7 +712,7 @@ func ReadSQLiteDBCols(sdb *sqlite.Conn, dbTable, sortCol, sortDir string, ignore
 	}
 
 	// Execute the query and retrieve the data
-	_, _, dataRows, err = SQLiteRunQuery(sdb, WebUI, dbQuery, ignoreBinary, ignoreNull)
+	_, _, dataRows, err = SQLiteRunQuery(sdb, QuerySourceWebUI, dbQuery, ignoreBinary, ignoreNull)
 	if err != nil {
 		return dataRows, err
 	}
@@ -638,8 +814,116 @@ func ReadSQLiteDBCSV(sdb *sqlite.Conn, dbTable string) ([][]string, error) {
 	return resultSet, nil
 }
 
-// SanityCheck performs basic sanity checks of an uploaded database.
-func SanityCheck(fileName string) (tables []string, err error) {
+// SQLiteGetColumnsLive is used by our AMQP backend nodes to retrieve the list of columns from a SQLite database
+func SQLiteGetColumnsLive(baseDir, dbOwner, dbName, table string) (columns []sqlite.Column, err error) {
+	// Open the database on the local node
+	var sdb *sqlite.Conn
+	sdb, err = OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName)
+	if err != nil {
+		return
+	}
+	defer sdb.Close()
+
+	// Verify the requested table or view we're about to query does exist
+	var tablesViews []string
+	tablesViews, err = TablesAndViews(sdb, dbName)
+	if err != nil {
+		return
+	}
+	tableOrViewFound := false
+	for _, t := range tablesViews {
+		if t == table {
+			tableOrViewFound = true
+		}
+	}
+	if !tableOrViewFound {
+		err = errors.New("Provided table or view name doesn't exist in this database")
+		return
+	}
+
+	// Retrieve the list of columns for the table
+	columns, err = sdb.Columns("", table)
+	return
+}
+
+// SQLiteGetIndexesLive is used by our AMQP backend nodes to retrieve the list of indexes from a SQLite database
+func SQLiteGetIndexesLive(baseDir, dbOwner, dbName string) (indexes []APIJSONIndex, err error) {
+	// Open the database on the local node
+	var sdb *sqlite.Conn
+	sdb, err = OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName)
+	if err != nil {
+		return
+	}
+	defer sdb.Close()
+
+	// Retrieve the list of indexes
+	var idx map[string]string
+	idx, err = sdb.Indexes("")
+	if err != nil {
+		return
+	}
+
+	// Retrieve the details for each index
+	for nam, tab := range idx {
+		oneIndex := APIJSONIndex{
+			Name:    nam,
+			Table:   tab,
+			Columns: []APIJSONIndexColumn{},
+		}
+		var cols []sqlite.Column
+		cols, err = sdb.IndexColumns("", nam)
+		if err != nil {
+			return
+		}
+		for _, k := range cols {
+			oneIndex.Columns = append(oneIndex.Columns, APIJSONIndexColumn{
+				CID:  k.Cid,
+				Name: k.Name,
+			})
+		}
+		indexes = append(indexes, oneIndex)
+	}
+	return
+}
+
+// SQLiteGetTablesLive is used by our AMQP backend nodes to retrieve the list of tables in a SQLite database
+func SQLiteGetTablesLive(baseDir, dbOwner, dbName string) (tables []string, err error) {
+	// Open the database on the local node
+	var sdb *sqlite.Conn
+	sdb, err = OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName)
+	if err != nil {
+		return
+	}
+	defer sdb.Close()
+
+	// Retrieve the list of tables
+	tables, err = Tables(sdb)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// SQLiteGetViewsLive is used by our AMQP backend nodes to retrieve the list of views in a SQLite database
+func SQLiteGetViewsLive(baseDir, dbOwner, dbName string) (views []string, err error) {
+	// Open the database on the local node
+	var sdb *sqlite.Conn
+	sdb, err = OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName)
+	if err != nil {
+		return
+	}
+	defer sdb.Close()
+
+	// Retrieve the list of views
+	views, err = Views(sdb)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// SQLiteSanityCheck performs basic sanity checks of an uploaded database.
+func SQLiteSanityCheck(fileName string) (tables []string, err error) {
 	// Perform a read on the database, as a basic sanity check to ensure it's really a SQLite database
 	sqliteDB, err := sqlite.Open(fileName, sqlite.OpenReadOnly)
 	if err != nil {
@@ -656,7 +940,7 @@ func SanityCheck(fileName string) (tables []string, err error) {
 		// Retrieve a row from the integrity check result
 		var a string
 		if err = s.Scan(&a); err != nil {
-			// Error where reading the row, so ensure the integrity check returns a failure result
+			// Error when reading the row, so ensure the integrity check returns a failure result
 			ok = false
 			return err
 		}
@@ -768,10 +1052,10 @@ func SQLiteRunQuery(sdb *sqlite.Conn, querySource QuerySource, dbQuery string, i
 					b, isNull = s.ScanBlob(i)
 					if !isNull {
 						switch querySource {
-						case API:
+						case QuerySourceAPI:
 							row = append(row, DataValue{Name: dataRows.ColNames[i], Type: Binary,
 								Value: base64.StdEncoding.EncodeToString(b)})
-						case Internal:
+						case QuerySourceInternal:
 							stringVal := "x'"
 							for _, c := range b {
 								stringVal += fmt.Sprintf("%02x", c)
@@ -795,7 +1079,7 @@ func SQLiteRunQuery(sdb *sqlite.Conn, querySource QuerySource, dbQuery string, i
 			if isNull && !ignoreNull {
 				// Different sources of the query have different requirements for the output
 				switch querySource {
-				case API, Internal:
+				case QuerySourceAPI, QuerySourceInternal:
 					row = append(row, DataValue{Name: dataRows.ColNames[i], Type: Null})
 				default:
 					row = append(row, DataValue{Name: dataRows.ColNames[i], Type: Null, Value: "<i>NULL</i>"})
@@ -848,9 +1132,9 @@ func SQLiteRunQueryDefensive(w http.ResponseWriter, r *http.Request, querySource
 	var logID int64
 	var source string
 	switch querySource {
-	case API:
+	case QuerySourceAPI:
 		source = "api"
-	case Visualisation:
+	case QuerySourceVisualisation:
 		source = "vis"
 	default:
 		return SQLiteRecordSet{}, fmt.Errorf("Unknown source in SQLiteRunQueryDefensive()")
@@ -878,6 +1162,29 @@ func SQLiteRunQueryDefensive(w http.ResponseWriter, r *http.Request, querySource
 	return dataRows, err
 }
 
+// SQLiteRunQueryLive is used by our AMQP backend infrastructure to run a user provided SQLite query
+func SQLiteRunQueryLive(baseDir, dbOwner, dbName, loggedInUser, query string) (records SQLiteRecordSet, err error) {
+	// Open the database on the local node
+	var sdb *sqlite.Conn
+	sdb, err = OpenSQLiteDatabaseLive(baseDir, dbOwner, dbName)
+	if err != nil {
+		return
+	}
+	defer sdb.Close()
+
+	// TODO: Probably add in the before and after logging info at some point (as per function above),
+	//       so we can analyse query execution times
+
+	// Execute the SQLite select query (or queries)
+	_, _, records, err = SQLiteRunQuery(sdb, QuerySourceAPI, query, false, false)
+	if err != nil {
+		log.Printf("Error when preparing statement by '%s' for LIVE database (%s/%s): '%s'\n", SanitiseLogString(loggedInUser),
+			SanitiseLogString(dbOwner), SanitiseLogString(dbName), SanitiseLogString(err.Error()))
+		return SQLiteRecordSet{}, err
+	}
+	return
+}
+
 // SQLiteVersionNumber returns the version number of the available SQLite library, in 300X00Y format.
 func SQLiteVersionNumber() int32 {
 	return sqlite.VersionNumber()
diff --git a/common/types.go b/common/types.go
index e04475f23..a0306fe13 100644
--- a/common/types.go
+++ b/common/types.go
@@ -63,11 +63,11 @@ const MinioFolderChars = 6
 type QuerySource int
 
 const (
-	WebUI QuerySource = iota
-	DB4S
-	Visualisation
-	API
-	Internal
+	QuerySourceWebUI QuerySource = iota
+	QuerySourceDB4S
+	QuerySourceVisualisation
+	QuerySourceAPI
+	QuerySourceInternal
 )
 
 // SetAccessType is used for setting the public flag of a database
@@ -79,6 +79,14 @@ const (
 	KeepCurrentAccessType
 )
 
+// SetDBType is used for setting what type of database we're working with
+type SetDBType int
+
+const (
+	DBTypeStandard SetDBType = iota
+	DBTypeLive
+)
+
 // ************************
 // Configuration file types
 
@@ -93,6 +101,7 @@ type TomlConfig struct {
 	Licence     LicenceInfo
 	Memcache    MemcacheInfo
 	Minio       MinioInfo
+	MQ          MQInfo
 	Pg          PGInfo
 	Sign        SigningInfo
 	Web         WebInfo
@@ -165,6 +174,14 @@ type MinioInfo struct {
 	Server    string
 }
 
+// MQInfo contains the AMQP backend connection parameters
+type MQInfo struct {
+	Password string `toml:"password"`
+	Port     int    `toml:"port"`
+	Server   string `toml:"server"`
+	Username string `toml:"username"`
+}
+
 // PGInfo contains the PostgreSQL connection parameters
 type PGInfo struct {
 	Database       string
diff --git a/common/userinput.go b/common/userinput.go
index 93f277774..a8f7d40e1 100644
--- a/common/userinput.go
+++ b/common/userinput.go
@@ -4,6 +4,7 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"html"
 	"log"
 	"net/http"
 	"net/url"
@@ -160,6 +161,22 @@ func GetFormLicence(r *http.Request) (licenceName string, err error) {
 	return licenceName, nil
 }
 
+// GetFormLive returns the "live" value (if any) present in the form data
+func GetFormLive(r *http.Request) (live bool, err error) {
+	l := r.PostFormValue("live")
+	if l == "" || strings.ToLower(l) == "false" {
+		return
+	}
+
+	// Check for true value
+	live, err = strconv.ParseBool(l)
+	if err != nil {
+		err = fmt.Errorf("Error when converting live value '%s' to boolean: %v", html.EscapeString(l), err)
+		return
+	}
+	return
+}
+
 // GetFormODC returns the database owner, database name, and commit (if any) present in the form data
 func GetFormODC(r *http.Request) (userName string, dbName string, commitID string, err error) {
 	// Extract the database owner name
@@ -282,7 +299,7 @@ func GetFormTable(r *http.Request, allowGet bool) (table string, err error) {
 		return "", nil
 	}
 
-	// Unescape, then validate the owner name
+	// Unescape, then validate the table name
 	table, err = url.QueryUnescape(t)
 	if err != nil {
 		return "", err
diff --git a/common/util.go b/common/util.go
index 1f2b586bb..fe2924421 100644
--- a/common/util.go
+++ b/common/util.go
@@ -43,58 +43,15 @@ func AddDatabase(loggedInUser, dbOwner, dbFolder, dbName string, createBranch bo
 		return 0, "", "", errors.New("You cannot upload a database for another user")
 	}
 
-	// Create a temporary file to store the database in
-	tempDB, err := os.CreateTemp(Conf.DiskCache.Directory, "dbhub-upload-")
+	// Store the incoming database to a temporary file on disk, and sanity check it
+	var sha string
+	var sTbls []string
+	var tempDB *os.File
+	numBytes, tempDB, sha, sTbls, err = WriteDBtoDisk(loggedInUser, dbOwner, dbFolder, dbName, newDB)
 	if err != nil {
-		log.Printf("Error creating temporary file. User: '%s', Database: '%s%s%s', Error: %v\n", loggedInUser,
-			SanitiseLogString(dbOwner), SanitiseLogString(dbFolder), SanitiseLogString(dbName), err)
 		return
 	}
-	tempDBName := tempDB.Name()
-
-	// Delete the temporary file when this function finishes
-	defer os.Remove(tempDBName)
-
-	// Write the database to the temporary file, so we can try opening it with SQLite to verify it's ok
-	bufSize := 16 << 20 // 16MB
-	buf := make([]byte, bufSize)
-	numBytes, err = io.CopyBuffer(tempDB, newDB, buf)
-	if err != nil {
-		log.Printf("Error when writing the uploaded db to a temp file. User: '%s', Database: '%s%s%s' "+
-			"Error: %v\n", loggedInUser, SanitiseLogString(dbOwner), SanitiseLogString(dbFolder), SanitiseLogString(dbName), err)
-		return
-	}
-	if numBytes == 0 {
-		err = errors.New("Copying file failed")
-		return
-	}
-
-	// Sanity check the uploaded database, and get the list of tables in the database
-	sTbls, err := SanityCheck(tempDBName)
-	if err != nil {
-		return
-	}
-
-	// Return to the start of the temporary file
-	newOff, err := tempDB.Seek(0, 0)
-	if err != nil {
-		log.Printf("Seeking on the temporary file failed: %v\n", err.Error())
-		return
-	}
-	if newOff != 0 {
-		err = errors.New("Seeking to the start of the temporary file failed")
-		return
-	}
-
-	// Generate sha256 of the uploaded file
-	// TODO: Using an io.MultiWriter to feed data from newDB into both the temp file and this sha256 function at the
-	// TODO  same time might be a better approach here
-	s := sha256.New()
-	_, err = io.CopyBuffer(s, tempDB, buf)
-	if err != nil {
-		return
-	}
-	sha := hex.EncodeToString(s.Sum(nil))
+	defer os.Remove(tempDB.Name())
 
 	// If we were given a SHA256 for the file, make sure it matches our calculated one
 	if dbSha != "" && dbSha != sha {
@@ -102,7 +59,7 @@ func AddDatabase(loggedInUser, dbOwner, dbFolder, dbName string, createBranch bo
 		return
 	}
 
-	// Check if the database already exists in the system
+	// Figure out the branch structure to use
 	var defBranch string
 	needDefaultBranchCreated := false
 	var branches map[string]BranchEntry
@@ -335,12 +292,13 @@ func AddDatabase(loggedInUser, dbOwner, dbFolder, dbName string, createBranch bo
 	}
 
 	// Return to the start of the temporary file again
-	newOff, err = tempDB.Seek(0, 0)
+	var newOffset int64
+	newOffset, err = tempDB.Seek(0, 0)
 	if err != nil {
 		log.Printf("Seeking on the temporary file (2nd time) failed: %v\n", err.Error())
 		return
 	}
-	if newOff != 0 {
+	if newOffset != 0 {
 		return 0, "", "", errors.New("Seeking to start of temporary database file didn't work")
 	}
 
@@ -394,7 +352,7 @@ func AddDatabase(loggedInUser, dbOwner, dbFolder, dbName string, createBranch bo
 		}
 	}
 
-	// If the database didn't previous exist, add the user to the watch list for the database
+	// If the database didn't previously exist, add the user to the watch list for the database
 	if !exists {
 		err = ToggleDBWatch(loggedInUser, dbOwner, dbFolder, dbName)
 		if err != nil {
@@ -1132,3 +1090,56 @@ func StatusUpdateCheck(dbOwner, dbFolder, dbName string, thisID int, userName st
 	}
 	return
 }
+
+// WriteDBtoDisk gets an uploaded database file from the user's incoming request, and writes it to a local temporary file
+func WriteDBtoDisk(loggedInUser, dbOwner, dbFolder, dbName string, newDB io.Reader) (numBytes int64, tempDB *os.File, sha string, sTbls []string, err error) {
+	// Create a temporary file to store the database in
+	tempDB, err = os.CreateTemp(Conf.DiskCache.Directory, "dbhub-upload-")
+	if err != nil {
+		log.Printf("Error creating temporary file. User: '%s', Database: '%s%s%s', Error: %v\n", loggedInUser,
+			SanitiseLogString(dbOwner), SanitiseLogString(dbFolder), SanitiseLogString(dbName), err)
+		return
+	}
+	tempDBName := tempDB.Name()
+
+	// Write the database to the temporary file, so we can try opening it with SQLite to verify it's ok
+	bufSize := 16 << 22 // 64MB
+	buf := make([]byte, bufSize)
+	numBytes, err = io.CopyBuffer(tempDB, newDB, buf)
+	if err != nil {
+		log.Printf("Error when writing the uploaded db to a temp file. User: '%s', Database: '%s%s%s' "+
+			"Error: %v\n", loggedInUser, SanitiseLogString(dbOwner), SanitiseLogString(dbFolder), SanitiseLogString(dbName), err)
+		return
+	}
+	if numBytes == 0 {
+		err = errors.New("Copying file failed")
+		return
+	}
+
+	// Sanity check the uploaded database, and get the list of tables in the database
+	sTbls, err = SQLiteSanityCheck(tempDBName)
+	if err != nil {
+		return
+	}
+
+	// Return to the start of the temporary file
+	var newOffSet int64
+	newOffSet, err = tempDB.Seek(0, 0)
+	if err != nil {
+		log.Printf("Seeking on the temporary file failed: %s\n", err.Error())
+		return
+	}
+	if newOffSet != 0 {
+		err = errors.New("Seeking to the start of the temporary file failed")
+		return
+	}
+
+	// Generate sha256 of the uploaded file
+	s := sha256.New()
+	_, err = io.CopyBuffer(s, tempDB, buf)
+	if err != nil {
+		return
+	}
+	sha = hex.EncodeToString(s.Sum(nil))
+	return
+}
diff --git a/cypress/test_data/Join Testing with index.sqlite b/cypress/test_data/Join Testing with index.sqlite
new file mode 100644
index 000000000..0e7d698ff
Binary files /dev/null and b/cypress/test_data/Join Testing with index.sqlite differ
diff --git a/docker/Dockerfile b/docker/Dockerfile
index ce0c697fb..739975cdc 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,13 +1,23 @@
 # vim:set ft=dockerfile:
 FROM alpine:3.17
+# FIXME: Consider potentially moving to one of the RabbitMQ alpine images
+#        as a base instead.  eg: https://hub.docker.com/_/rabbitmq
 
 LABEL maintainer="Justin Clift <justin@postgresql.org>"
 
-# Install Git, Go, Memcached, and PostgreSQL
+# Install Git, Go, Memcached, Minio, OpenRC, PostgreSQL, and RabbitMQ
 RUN  \
     apk update && \
     apk upgrade && \
-    apk add --no-cache ca-certificates 'curl>7.61.0' git go libc-dev memcached postgresql sqlite-dev yarn
+    apk add --no-cache ca-certificates 'curl>7.61.0' git go libc-dev memcached minio openrc postgresql sqlite-dev yarn && \
+    apk add rabbitmq-server --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing/ && \
+    rc-update add memcached default && \
+    rc-update add minio default && \
+    rc-update add postgresql default && \
+    rc-update add rabbitmq-server default && \
+    mkdir /etc/rabbitmq && \
+    rabbitmq-plugins enable rabbitmq_management && \
+    rabbitmq-plugins enable rabbitmq_top
 
 # Create the DBHub.io OS user
 RUN addgroup dbhub && \
@@ -16,92 +26,56 @@ RUN addgroup dbhub && \
 # Location of the DBHub.io source code
 ENV DBHUB_SOURCE /dbhub.io
 
-### Memcached
-
-# Generate script for starting Memcached
-RUN echo "/usr/bin/memcached -u memcached -d" >> /usr/local/bin/start.sh && \
-    chmod +x /usr/local/bin/start.sh
-
-### Minio (everything except downloading the server executable)
-
-# Create the Minio OS user
-RUN addgroup minio && \
-    adduser -D -S -s /bin/ash -G minio minio
-
-# Install Minio
-ENV MINIO_UPDATE off
+# Set Minio config variables
 ENV MINIO_ROOT_USER minio
 ENV MINIO_ROOT_PASSWORD minio123
-ENV MINIO_DATA /data/minio
-
-# Create Minio data directory
-RUN mkdir -p ${MINIO_DATA}
-RUN chown minio:minio ${MINIO_DATA}
-
-# Create Minio user .profile and startup script
-RUN su - minio -c "echo export MINIO_UPDATE=${MINIO_UPDATE} >> .profile" && \
-    su - minio -c "echo export MINIO_ROOT_USER=${MINIO_ROOT_USER} >> .profile" && \
-    su - minio -c "echo export MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD} >> .profile" && \
-    su - dbhub -c "echo export MINIO_ROOT_USER=${MINIO_ROOT_USER} >> .profile" && \
-    su - dbhub -c "echo export MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD} >> .profile" && \
-    echo "su - minio -c '/usr/local/bin/minio server ${MINIO_DATA} &'" >> /usr/local/bin/start.sh
-
-### PostgreSQL
-
-# Create PostgreSQL directories
-ENV PGDATA /data/postgresql
-RUN su - postgres -c "echo export PGDATA=${PGDATA} >> .profile"
-RUN su - postgres -c "echo export DBHUB_SOURCE=${DBHUB_SOURCE} >> .profile"
-RUN mkdir -p "$PGDATA" && \
-    chown -R postgres:postgres "$PGDATA" && \
-    chmod 777 "$PGDATA" # this 777 will be replaced by 700 at runtime (allows semi-arbitrary "--user" values)
-RUN mkdir /run/postgresql && \
-    chown postgres:postgres /run/postgresql
-
-# Add script pieces for initialising & starting PostgreSQL
-RUN echo "mkdir -p ${PGDATA}" >> /usr/local/bin/init.sh && \
-    echo "chown -R postgres:postgres ${PGDATA}" >> /usr/local/bin/init.sh && \
-    echo "chmod 777 ${PGDATA}" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'pg_ctl -D ${PGDATA} initdb'" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'pg_ctl -D ${PGDATA} start'" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'createuser -d dbhub'" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'createdb -O dbhub dbhub'" >> /usr/local/bin/init.sh && \
-    echo "su - dbhub -c 'psql dbhub < /${DBHUB_SOURCE}/database/dbhub.sql'" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'pg_ctl -D ${PGDATA} stop'" >> /usr/local/bin/init.sh && \
-    echo "su - postgres -c 'pg_ctl -D ${PGDATA} start'" >> /usr/local/bin/start.sh && \
+
+RUN sed -i "s/^MINIO_ROOT_USER=\"change-me\"/MINIO_ROOT_USER=\"${MINIO_ROOT_USER}\"/" /etc/conf.d/minio && \
+    sed -i "s/^MINIO_ROOT_PASSWORD=\"change-me\"/MINIO_ROOT_PASSWORD=\"${MINIO_ROOT_PASSWORD}\"/" /etc/conf.d/minio
+
+# Run each of our daemon dependencies at least once to ensure they initialise ok, and populate the DBHub.io database
+RUN echo "openrc nonetwork" >> /usr/local/bin/init.sh && \
+    echo "openrc default stop 2>&1 | grep -v 'Read-only file system'" >> /usr/local/bin/init.sh && \
+    echo "createuser -U postgres -d dbhub" >> /usr/local/bin/init.sh && \
+    echo "createdb -U postgres -O dbhub dbhub" >> /usr/local/bin/init.sh && \
+    echo "su - dbhub -c 'psql dbhub < ${DBHUB_SOURCE}/database/dbhub.sql'" >> /usr/local/bin/init.sh && \
+    echo "rc-service memcached stop 2>&1 | grep -v 'Read-only file system'" >> /usr/local/bin/init.sh && \
+    echo "rc-service minio stop 2>&1 | grep -v 'Read-only file system'" >> /usr/local/bin/init.sh && \
+    echo "rc-service postgresql stop 2>&1 | grep -v 'Read-only file system'" >> /usr/local/bin/init.sh && \
+    echo "rc-service rabbitmq-server stop 2>&1 | grep -v 'Read-only file system'" >> /usr/local/bin/init.sh && \
     chmod +x /usr/local/bin/init.sh
 
 # Set the dependencies and DBHub.io daemons to automatically start
 ENTRYPOINT /usr/local/bin/start.sh
 
-### DBHub.io (initial dir creation only)
-
 # Create directores for the DBHub daemons
-RUN mkdir -p /var/log/dbhub ~dbhub/.dbhub/disk_cache ~dbhub/.dbhub/email_queue && \
-    chown -R dbhub:dbhub /var/log/dbhub ~dbhub/.dbhub/disk_cache ~dbhub/.dbhub/email_queue && \
-    chmod 700 /var/log/dbhub ~dbhub/.dbhub/disk_cache ~dbhub/.dbhub/email_queue
-
-### Other pieces
+RUN mkdir -p /var/log/dbhub ~dbhub/.dbhub/disk_cache && \
+    chown -R dbhub:dbhub /var/log/dbhub ~dbhub/.dbhub/disk_cache && \
+    chmod 700 /var/log/dbhub ~dbhub/.dbhub/disk_cache
 
-# Config file
+# DBHub.io config file
 ENV CONFIG_FILE ${DBHUB_SOURCE}/docker/config.toml
 
-# Download the latest Minio server binary
-RUN curl -L -o /usr/local/bin/minio https://dl.minio.io/server/minio/release/linux-amd64/minio && \
-    chmod +x /usr/local/bin/minio
-
 # Build the Go debugger (Delve)
 RUN GOBIN=/usr/local/bin go install github.com/go-delve/delve/cmd/dlv@latest
 
 # Add script pieces for starting DBHub.io services
-# Note that we only background the webui and api daemons.  The db4s daemon is left running, to prevent start.sh from exiting
+# These don't use openrc.  Not sure if it'd be useful.  Maybe a task for a different day?
 RUN echo "echo 127.0.0.1 docker-dev.dbhub.io docker-dev >> /etc/hosts" >> /usr/local/bin/start.sh && \
+    echo "openrc default" >> /usr/local/bin/start.sh && \
+    echo "" >> /usr/local/bin/start.sh && \
+    echo "# Wait for RabbitMQ to start before launching the DBHub.io daemons" >> /usr/local/bin/start.sh && \
+    echo "sleep 15" >> /usr/local/bin/start.sh && \
+    echo "" >> /usr/local/bin/start.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} /usr/local/bin/dbhub-webui >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/start.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} /usr/local/bin/dbhub-api >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/start.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} /usr/local/bin/dbhub-db4s >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/start.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} /usr/local/bin/dbhub-live node1 /tmp/node1 >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/start.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} /usr/local/bin/dbhub-live node2 /tmp/node2 >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/start.sh && \
     echo "while :; do" >> /usr/local/bin/start.sh && \
     echo "  sleep 5" >> /usr/local/bin/start.sh && \
-    echo "done" >> /usr/local/bin/start.sh
+    echo "done" >> /usr/local/bin/start.sh && \
+    chmod +x /usr/local/bin/start.sh
 
 # Create script to compile DBHub.io daemons
 RUN echo "cd ${DBHUB_SOURCE}" >> /usr/local/bin/compile.sh && \
@@ -112,6 +86,8 @@ RUN echo "cd ${DBHUB_SOURCE}" >> /usr/local/bin/compile.sh && \
     echo "go build -gcflags \"all=-N -l\" -buildvcs=false -o /usr/local/bin/dbhub-api ." >> /usr/local/bin/compile.sh && \
     echo "cd ${DBHUB_SOURCE}/db4s" >> /usr/local/bin/compile.sh && \
     echo "go build -gcflags \"all=-N -l\" -buildvcs=false -o /usr/local/bin/dbhub-db4s ." >> /usr/local/bin/compile.sh && \
+    echo "cd ${DBHUB_SOURCE}/live" >> /usr/local/bin/compile.sh && \
+    echo "go build -gcflags \"all=-N -l\" -buildvcs=false -o /usr/local/bin/dbhub-live ." >> /usr/local/bin/compile.sh && \
     echo "cd ${DBHUB_SOURCE}/webui" >> /usr/local/bin/compile.sh && \
     echo "go build -gcflags \"all=-N -l\" -buildvcs=false -o /usr/local/bin/dbhub-webui ." >> /usr/local/bin/compile.sh && \
     echo "/usr/local/bin/restart.sh" >> /usr/local/bin/compile.sh && \
@@ -122,6 +98,7 @@ RUN echo "# Kill the existing running daemons" >> /usr/local/bin/restart.sh && \
     echo "pkill dbhub-webui" >> /usr/local/bin/restart.sh && \
     echo "pkill dbhub-api" >> /usr/local/bin/restart.sh && \
     echo "pkill dbhub-db4s" >> /usr/local/bin/restart.sh && \
+    echo "pkill dbhub-live" >> /usr/local/bin/restart.sh && \
     echo "pkill dlv" >> /usr/local/bin/restart.sh && \
     echo "" >> /usr/local/bin/restart.sh && \
     echo "# Restart the daemons" >> /usr/local/bin/restart.sh && \
@@ -132,6 +109,8 @@ RUN echo "# Kill the existing running daemons" >> /usr/local/bin/restart.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup /usr/local/bin/dbhub-webui >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/restart.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup /usr/local/bin/dbhub-api >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/restart.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup /usr/local/bin/dbhub-db4s >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/restart.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup /usr/local/bin/dbhub-live node1 /tmp/node1 >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/restart.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup /usr/local/bin/dbhub-live node2 /tmp/node2 >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/restart.sh && \
     echo "" >> /usr/local/bin/restart.sh && \
     echo "# Delay long enough for the DBHub.io daemons to start" >> /usr/local/bin/restart.sh && \
     echo "sleep 1" >> /usr/local/bin/restart.sh && \
@@ -142,6 +121,7 @@ RUN echo "# Kill the existing running daemons" >> /usr/local/bin/debug.sh && \
     echo "pkill dbhub-webui" >> /usr/local/bin/debug.sh && \
     echo "pkill dbhub-api" >> /usr/local/bin/debug.sh && \
     echo "pkill dbhub-db4s" >> /usr/local/bin/debug.sh && \
+    echo "pkill dbhub-live" >> /usr/local/bin/debug.sh && \
     echo "pkill dlv" >> /usr/local/bin/debug.sh && \
     echo "" >> /usr/local/bin/debug.sh && \
     echo "# Restart the daemons" >> /usr/local/bin/debug.sh && \
@@ -152,6 +132,8 @@ RUN echo "# Kill the existing running daemons" >> /usr/local/bin/debug.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec /usr/local/bin/dbhub-webui >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/debug.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup dlv --listen=:2346 --headless=true --api-version=2 --accept-multiclient exec /usr/local/bin/dbhub-api >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/debug.sh && \
     echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup dlv --listen=:2347 --headless=true --api-version=2 --accept-multiclient exec /usr/local/bin/dbhub-db4s >>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/debug.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup dlv --listen=:2348 --headless=true --api-version=2 --accept-multiclient exec /usr/local/bin/dbhub-live node1 /tmp/node1>>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/debug.sh && \
+    echo "su - dbhub -c 'if [ -f "${DBHUB_SOURCE}/.env" ]; then source ${DBHUB_SOURCE}/.env; fi; CONFIG_FILE=${CONFIG_FILE} nohup dlv --listen=:2349 --headless=true --api-version=2 --accept-multiclient exec /usr/local/bin/dbhub-live node2 /tmp/node2>>/home/dbhub/output.log 2>&1 &'" >> /usr/local/bin/debug.sh && \
     echo "" >> /usr/local/bin/debug.sh && \
     echo "# Delay long enough for the DBHub.io daemons to start" >> /usr/local/bin/debug.sh && \
     echo "sleep 1" >> /usr/local/bin/debug.sh && \
@@ -161,6 +143,6 @@ RUN echo "# Kill the existing running daemons" >> /usr/local/bin/debug.sh && \
 RUN cd / && git clone --branch master --depth 5 https://github.com/sqlitebrowser/dbhub.io
 RUN /usr/local/bin/compile.sh
 
-# Initialise PostgreSQL and Minio
+# Populate the DBHub.io database
 WORKDIR /usr/local/bin
 RUN init.sh
diff --git a/docker/config.toml b/docker/config.toml
index 9c10238d0..b78df42cc 100644
--- a/docker/config.toml
+++ b/docker/config.toml
@@ -1,6 +1,6 @@
 [db4s]
 server = "docker-dev.dbhub.io"
-port = 9445
+port = 5550
 certificate = "/dbhub.io/docker/certs/docker-dev.dbhub.io.cert.pem"
 certificate_key = "/dbhub.io/docker/certs/docker-dev.dbhub.io.key.pem"
 ca_chain = "/dbhub.io/docker/certs/ca-chain-docker.cert.pem"
@@ -32,6 +32,12 @@ access_key = "minio"
 secret = "minio123"
 https = false
 
+[mq]
+password = "guest"
+port = 5672
+server = "localhost"
+username = "guest"
+
 [pg]
 database = "dbhub"
 num_connections = 45
diff --git a/go.mod b/go.mod
index 09ee41638..7dacc382e 100644
--- a/go.mod
+++ b/go.mod
@@ -13,46 +13,40 @@ replace (
 require (
 	github.com/BurntSushi/toml v0.3.1
 	github.com/NYTimes/gziphandler v1.1.1
+	github.com/aquilax/truncate v1.0.0
 	github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b
 	github.com/bradleypeabody/gorilla-sessions-memcache v0.0.0-20181103040241-659414f458e1
 	github.com/go-playground/validator/v10 v10.3.0
 	github.com/gorilla/sessions v1.2.0
 	github.com/gwenn/gosqlite v0.0.0-20200521090053-24878be1a237
-	github.com/hectane/hectane v0.3.2
 	github.com/jackc/pgx v2.11.0+incompatible
 	github.com/minio/minio-go v6.0.14+incompatible
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/pkg/errors v0.9.1
+	github.com/rabbitmq/amqp091-go v1.7.0
 	github.com/segmentio/ksuid v1.0.3
+	github.com/smtp2go-oss/smtp2go-go v1.0.2
 	github.com/sqlitebrowser/github_flavored_markdown v0.0.0-20190120045821-b8cf8f054e47
 	golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b
 	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
 )
 
 require (
-	github.com/Freeaqingme/dkim v0.0.0-20160606200812-57418d2fbdcd // indirect
-	github.com/aquilax/truncate v1.0.0 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/go-ini/ini v1.56.0 // indirect
 	github.com/go-playground/locales v0.13.0 // indirect
 	github.com/go-playground/universal-translator v0.17.0 // indirect
 	github.com/go-stack/stack v1.8.0 // indirect
 	github.com/golang/protobuf v1.4.2 // indirect
-	github.com/google/uuid v1.1.1 // indirect
 	github.com/gorilla/css v1.0.0 // indirect
 	github.com/gorilla/securecookie v1.1.1 // indirect
 	github.com/gwenn/yacr v0.0.0-20200112083327-bbe82c1f4d60 // indirect
-	github.com/hectane/go-attest v0.1.2 // indirect
-	github.com/hectane/go-nonblockingchan v0.1.0 // indirect
 	github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 // indirect
-	github.com/kennygrant/sanitize v1.2.4 // indirect
-	github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
 	github.com/leodido/go-urn v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.6 // indirect
 	github.com/mattn/go-isatty v0.0.12 // indirect
 	github.com/memcachier/mc v2.0.1+incompatible // indirect
 	github.com/microcosm-cc/bluemonday v1.0.16 // indirect
-	github.com/pborman/uuid v1.2.0 // indirect
 	github.com/russross/blackfriday v2.0.0+incompatible // indirect
 	github.com/sergi/go-diff v1.1.0 // indirect
 	github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24 // indirect
@@ -63,9 +57,7 @@ require (
 	github.com/shurcooL/highlight_go v0.0.0-20191220051317-782971ddf21b // indirect
 	github.com/shurcooL/octicon v0.0.0-20191102190552-cbb32d6a785c // indirect
 	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
-	github.com/sirupsen/logrus v1.6.0 // indirect
 	github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 // indirect
-	github.com/smtp2go-oss/smtp2go-go v1.0.2 // indirect
 	github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d // indirect
 	github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e // indirect
 	github.com/sqlitebrowser/blackfriday v9.0.0+incompatible // indirect
diff --git a/go.sum b/go.sum
index 0b0b2e8a8..ee689ca67 100644
--- a/go.sum
+++ b/go.sum
@@ -1,8 +1,6 @@
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/Freeaqingme/dkim v0.0.0-20160606200812-57418d2fbdcd h1:OXAdgeC8/sNLxo6w6GjeW/yTU0iLrcv6BZXzbsgHZLY=
-github.com/Freeaqingme/dkim v0.0.0-20160606200812-57418d2fbdcd/go.mod h1:2jaO1ZDxGuwzrfRhIe1QKvws/FY3SJ9f1EMNLQLTa0g=
 github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cqUQ3I=
 github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c=
 github.com/aquilax/truncate v1.0.0 h1:UgIGS8U/aZ4JyOJ2h3xcF5cSQ06+gGBnjxH2RUHJe0U=
@@ -43,9 +41,6 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
@@ -59,22 +54,12 @@ github.com/gwenn/gosqlite v0.0.0-20200521090053-24878be1a237/go.mod h1:WBYs9HfQG
 github.com/gwenn/yacr v0.0.0-20200110180258-a66d8c42d0ff/go.mod h1:5SNcBGxZ5OaJAMJCSI/x3V7SGsvXqbwnwP/sHZLgYsw=
 github.com/gwenn/yacr v0.0.0-20200112083327-bbe82c1f4d60 h1:JX4Yy6S9U/f3Jix82M58NLIAFeW/UjBFVrnYn5GS4X8=
 github.com/gwenn/yacr v0.0.0-20200112083327-bbe82c1f4d60/go.mod h1:Ps/gikIXcn2rRmeP0HQ9EvUYJrfrjAi51Wg8acsrkP0=
-github.com/hectane/go-attest v0.1.2 h1:HzAy7PhILWGy3Vr6WsTFG4k+8csZ7rYsgB9zO3HD+RE=
-github.com/hectane/go-attest v0.1.2/go.mod h1:gxESRl/EHIwBfuD9xidptRiaabPkeyoDYGkIkQoOlm4=
-github.com/hectane/go-nonblockingchan v0.1.0 h1:w5dFzLYim23KoK64xqfA0iSMNMA8ruLXvGkyXlZBDFY=
-github.com/hectane/go-nonblockingchan v0.1.0/go.mod h1:Ztuu6NIB+3zEHbsCEXcynf5a4B49/PofiBiQUGDGbRw=
-github.com/hectane/hectane v0.3.2 h1:UyJMWFHtKNiK40cJvfzi/a3PuUTF0nf6kFRULt/joYc=
-github.com/hectane/hectane v0.3.2/go.mod h1:enmgBsfbzuxwQ9OLZeWYMWJt27wcegpNZORlhfw77p0=
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 h1:vr3AYkKovP8uR8AvSGGUK1IDqRa5lAAvEkZG1LKaCRc=
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgx v2.11.0+incompatible h1:IgFLUrzrhJj8mxbK44ZYExGVnjtfV4+TOkerb/XERV8=
 github.com/jackc/pgx v2.11.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/kennygrant/sanitize v1.2.4 h1:gN25/otpP5vAsO2djbMhF/LQX6R7+O1TB4yv8NzpJ3o=
-github.com/kennygrant/sanitize v1.2.4/go.mod h1:LGsjYYtgxbetdg5owWB2mpgUL6e2nfw2eObZ0u0qvak=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
 github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
@@ -95,12 +80,12 @@ github.com/minio/minio-go v6.0.14+incompatible h1:fnV+GD28LeqdN6vT2XdGKW8Qe/IfjJ
 github.com/minio/minio-go v6.0.14+incompatible/go.mod h1:7guKYtitv8dktvNUGrhzmNlA5wrAABTQXCoesZdFQO8=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/pborman/uuid v1.2.0 h1:J7Q5mO4ysT1dv8hyrUGHb9+ooztCXu1D8MY8DZYsu3g=
-github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rabbitmq/amqp091-go v1.7.0 h1:V5CF5qPem5OGSnEo8BoSbsDGwejg6VUJsKEdneaoTUo=
+github.com/rabbitmq/amqp091-go v1.7.0/go.mod h1:wfClAtY0C7bOHxd3GjmF26jEHn+rR/0B3+YV+Vn9/NI=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/russross/blackfriday v2.0.0+incompatible h1:cBXrhZNUf9C+La9/YpS+UHpUT8YD6Td9ZMSU9APFcsk=
 github.com/russross/blackfriday v2.0.0+incompatible/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
@@ -124,8 +109,6 @@ github.com/shurcooL/octicon v0.0.0-20191102190552-cbb32d6a785c h1:p3w+lTqXulfa3a
 github.com/shurcooL/octicon v0.0.0-20191102190552-cbb32d6a785c/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ=
 github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
-github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
@@ -141,22 +124,32 @@ github.com/sqlitebrowser/blackfriday v9.0.0+incompatible/go.mod h1:/zga9sqpWzcew
 github.com/sqlitebrowser/github_flavored_markdown v0.0.0-20190120045821-b8cf8f054e47 h1:s0+Ea95n1LrsKh6rtclU/9Qb2/5ofvnfnR7gDDiFTw8=
 github.com/sqlitebrowser/github_flavored_markdown v0.0.0-20190120045821-b8cf8f054e47/go.mod h1:8vPIKi5FslxCXEgfQxrFtWfdclGy6VWAc9NA1ZTYCJg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
+go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b h1:Qwe1rC8PSniVfAFPFJeyUkB+zcysC3RgJBAGk7eqBEU=
 golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -166,13 +159,16 @@ golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BG
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -189,12 +185,16 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=
 google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
@@ -206,11 +206,14 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi
 google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/inconshreveable/log15.v2 v2.0.0-20200109203555-b30bc20e4fd1 h1:iiHuQZCNgYPmFQxd3BBN/Nc5+dAwzZuq5y40s20oQw0=
 gopkg.in/inconshreveable/log15.v2 v2.0.0-20200109203555-b30bc20e4fd1/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s=
 gopkg.in/ini.v1 v1.46.0 h1:VeDZbLYGaupuvIrsYCEOe/L/2Pcs5n7hdO1ZTjporag=
 gopkg.in/ini.v1 v1.46.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/live/main.go b/live/main.go
new file mode 100644
index 000000000..77c01dc1e
--- /dev/null
+++ b/live/main.go
@@ -0,0 +1,316 @@
+package main
+
+// Internal daemon for running SQLite queries sent by the other DBHub.io daemons
+
+// FIXME: Note that all incoming AMQP requests _other_ than for database creation
+//        get handled by the same single goroutine.  This should likely be changed
+//        to something smarter, such as using a pool of worker goroutines to handle
+//        the requests.
+
+import (
+	"encoding/json"
+	"errors"
+	"log"
+	"os"
+	"path/filepath"
+
+	sqlite "github.com/gwenn/gosqlite"
+	com "github.com/sqlitebrowser/dbhub.io/common"
+)
+
+var (
+	baseDir string
+)
+
+func main() {
+	// Read node name and base directory from the command line
+	if len(os.Args) != 3 {
+		log.Println("You need to provide the name of this node, and the path to a directory")
+		log.Println("for storing the SQLite database files")
+		log.Println("eg:")
+		log.Fatalf("  %v node1 /some/directory", os.Args[0])
+	}
+	com.NodeName = os.Args[1]
+	baseDir = os.Args[2]
+
+	// If it doesn't exist, create the base directory for storing SQLite files
+	_, err := os.Stat(baseDir)
+	if err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			log.Fatal(err)
+		}
+
+		// The target location doesn't exist
+		err = os.MkdirAll(baseDir, 0750)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	// Read server configuration
+	if err = com.ReadConfig(); err != nil {
+		log.Fatalf("Configuration file problem\n\n%v", err)
+	}
+
+	// Connect to Minio server
+	err = com.ConnectMinio()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Connect to PostgreSQL server
+	err = com.ConnectPostgreSQL()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Connect to MQ server
+	ch, err := com.ConnectMQ(com.NodeName)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create queue for receiving new database creation requests
+	createQueue, err := com.MQCreateDBQueue(ch)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Start consuming database creation requests
+	createDBMsgs, err := ch.Consume(createQueue.Name, "", false, false, false, false, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	go func() {
+		for d := range createDBMsgs {
+			// Decode JSON request
+			var req com.LiveDBRequest
+			err = json.Unmarshal(d.Body, &req)
+			if err != nil {
+				log.Println(err)
+				err = com.MQCreateResponse(d, ch, com.NodeName, "failure")
+				if err != nil {
+					log.Printf("Error: occurred on live node '%s' in the create db code, while constructing an AMQP error message response: '%s'", com.NodeName, err)
+				}
+				continue
+			}
+
+			// Set up the live database locally
+			err = setupLiveDB(req.DBOwner, req.DBName)
+			if err != nil {
+				log.Println(err)
+				err = com.MQCreateResponse(d, ch, com.NodeName, "failure")
+				if err != nil {
+					log.Printf("Error: occurred on live node '%s' in the create db code, while constructing an AMQP error message response (location 2): '%s'", com.NodeName, err)
+				}
+				continue
+			}
+
+			// Respond to the creation request with a success message
+			err = com.MQCreateResponse(d, ch, com.NodeName, "success")
+			if err != nil {
+				continue
+			}
+		}
+	}()
+
+	// Create the queue for receiving database queries
+	queryQueue, err := com.MQCreateQueryQueue(ch, com.NodeName)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Start consuming database query requests
+	requests, err := ch.Consume(queryQueue.Name, "", false, false, false, false, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	go func() {
+		for msg := range requests {
+			if com.AmqpDebug {
+				log.Printf("'%s' received AMQP REQUEST (of not-yet-determined type)", com.NodeName)
+			}
+
+			// Decode JSON request
+			var req com.LiveDBRequest
+			err = json.Unmarshal(msg.Body, &req)
+			if err != nil {
+				log.Println(err)
+				err = com.MQErrorResponse(msg, ch, com.NodeName, err.Error())
+				if err != nil {
+					log.Printf("Error: occurred on '%s' the main live node switch{} while constructing an AMQP error message response: '%s'", com.NodeName, err)
+				}
+				continue
+			}
+
+			if com.AmqpDebug {
+				log.Printf("Decoded request on '%s'.  Correlation ID: '%s', request operation: '%s', request query: '%s'", com.NodeName, msg.CorrelationId, req.Operation, req.Query)
+			}
+
+			// Handle each operation
+			switch req.Operation {
+			case "columns":
+				var columns []sqlite.Column
+				columns, err = com.SQLiteGetColumnsLive(baseDir, req.DBOwner, req.DBName, req.Query) // We use the req.Query field to pass the table name
+				if err != nil {
+					err = com.MQColumnsResponse(msg, ch, com.NodeName, nil, err.Error())
+					if err != nil {
+						log.Printf("Error: occurred on '%s' in MQColumnsResponse() while constructing an AMQP error message response: '%s'", com.NodeName, err)
+					}
+					continue
+				}
+
+				// Return the columns list to the caller
+				err = com.MQColumnsResponse(msg, ch, com.NodeName, columns, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQColumnsResponse() while constructing the AMQP columns list response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			case "delete":
+				// Delete the database file on the node
+				err = removeLiveDB(req.DBOwner, req.DBName)
+				if err != nil {
+					err = com.MQDeleteResponse(msg, ch, com.NodeName, err.Error())
+					continue
+				}
+
+				// Return a success message (empty string in this case) to the caller
+				err = com.MQDeleteResponse(msg, ch, com.NodeName, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQDeleteResponse() while constructing the AMQP delete database response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			case "indexes":
+				var indexes []com.APIJSONIndex
+				indexes, err = com.SQLiteGetIndexesLive(baseDir, req.DBOwner, req.DBName)
+				if err != nil {
+					err = com.MQIndexesResponse(msg, ch, com.NodeName, nil, err.Error())
+					if err != nil {
+						log.Printf("Error: occurred on '%s' in MQIndexesResponse() while constructing an AMQP error message response: '%s'", com.NodeName, err)
+					}
+					continue
+				}
+
+				// Return the indexes list to the caller
+				err = com.MQIndexesResponse(msg, ch, com.NodeName, indexes, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQIndexesResponse() while constructing the AMQP indexes list response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			case "query":
+				var rows com.SQLiteRecordSet
+				rows, err = com.SQLiteRunQueryLive(baseDir, req.DBOwner, req.DBName, req.RequestingUser, req.Query)
+				if err != nil {
+					err = com.MQQueryResponse(msg, ch, com.NodeName, com.SQLiteRecordSet{}, err.Error())
+					if err != nil {
+						log.Printf("Error: occurred on '%s' in MQQueryResponse() while constructing an AMQP error message response: '%s'", com.NodeName, err)
+					}
+					continue
+				}
+
+				// Return the query response to the caller
+				err = com.MQQueryResponse(msg, ch, com.NodeName, rows, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQQueryResponse() while constructing the AMQP query response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			case "tables":
+				var tables []string
+				tables, err = com.SQLiteGetTablesLive(baseDir, req.DBOwner, req.DBName)
+				if err != nil {
+					err = com.MQTablesResponse(msg, ch, com.NodeName, nil, err.Error())
+					if err != nil {
+						log.Printf("Error: occurred on '%s' in MQTablesResponse() while constructing an AMQP error message response: '%s'", com.NodeName, err)
+					}
+					continue
+				}
+
+				// Return the tables list to the caller
+				err = com.MQTablesResponse(msg, ch, com.NodeName, tables, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQTablesResponse() while constructing the AMQP tables list response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			case "views":
+				var views []string
+				views, err = com.SQLiteGetViewsLive(baseDir, req.DBOwner, req.DBName)
+				if err != nil {
+					err = com.MQViewsResponse(msg, ch, com.NodeName, nil, err.Error())
+					if err != nil {
+						log.Printf("Error: occurred on '%s' in MQViewsResponse() while constructing an AMQP error message response: '%s'", com.NodeName, err)
+					}
+					continue
+				}
+
+				// Return the views list to the caller
+				err = com.MQViewsResponse(msg, ch, com.NodeName, views, "")
+				if err != nil {
+					log.Printf("Error: occurred on '%s' in MQViewsResponse() while constructing the AMQP views list response: '%s'", com.NodeName, err)
+				}
+				continue
+
+			default:
+				log.Printf("'%s' received unknown '%s' request on this queue for %s/%s", com.NodeName, req.Operation, req.DBOwner, req.DBName)
+			}
+		}
+	}()
+
+	log.Printf("Live server '%s' listening for requests", com.NodeName)
+
+	// Endless loop
+	var forever chan struct{}
+	<-forever
+
+	// Close the channel to the MQ server
+	_ = com.CloseMQChannel(ch)
+}
+
+// RemoveLiveDB deletes a live database from the local node.  For example, when the user deletes it from
+// their account.
+// Be aware, it leaves the database owners directory in place, to avoid any potential race condition of
+// trying to delete that directory while other databases in their account are being worked with
+func removeLiveDB(dbOwner, dbName string) (err error) {
+	// Get the path to the database file, and it's containing directory
+	dbDir := filepath.Join(baseDir, dbOwner, dbName)
+	dbPath := filepath.Join(dbDir, "live.sqlite")
+	if _, err = os.Stat(dbPath); err != nil {
+		// Something wrong with the database file
+		log.Println(err)
+		return
+	}
+
+	// Delete the "live.sqlite" file
+	// NOTE: If this seems to leave wal or other files hanging around in actual production use, we could
+	//       instead use filepath.RemoveAll(dbDir).  That should kill the containing directory and
+	//       all files within, thus not leave anything hanging around
+	err = os.Remove(dbPath)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Remove the containing directory
+	err = os.Remove(dbDir)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	if com.AmqpDebug {
+		log.Printf("Live node '%s': Database file '%s/%s' removed from filesystem path: '%s'",
+			com.NodeName, dbOwner, dbName, dbPath)
+	}
+	return
+}
+
+// setupLiveDB sets up a new instance of a given live database on the local node
+func setupLiveDB(dbOwner, dbName string) (err error) {
+	// Retrieve the uploaded database file from Minio, and save it to local disk
+	_, err = com.LiveRetrieveDatabaseMinio(baseDir, dbOwner, dbName)
+	return
+}
diff --git a/webui/main.go b/webui/main.go
index 0b4fa24d9..f78540c51 100644
--- a/webui/main.go
+++ b/webui/main.go
@@ -4,7 +4,9 @@ import (
 	"crypto/tls"
 	"encoding/csv"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"html"
 	"html/template"
 	"io"
 	"log"
@@ -3028,7 +3030,6 @@ func logReq(fn http.HandlerFunc) http.HandlerFunc {
 
 func main() {
 	// Read server configuration
-	// TODO: It might be sensible to add a config option pointing to the SQLite 3 library path for LD_LIBRARY_PATH purposes
 	var err error
 	if err = com.ReadConfig(); err != nil {
 		log.Fatalf("Configuration file problem\n\n%v", err)
@@ -3081,6 +3082,12 @@ func main() {
 		log.Fatalf(err.Error())
 	}
 
+	// Connect to MQ server
+	com.AmqpChan, err = com.ConnectMQ("webui server")
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	// Connect to the Memcached server
 	err = com.ConnectCache()
 	if err != nil {
@@ -3403,7 +3410,11 @@ func main() {
 
 	// Shut down nicely
 	com.DisconnectPostgreSQL()
+	if err != nil {
+		log.Println(err)
+	}
 
+	err = com.CloseMQChannel(com.AmqpChan)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -5200,8 +5211,13 @@ func uploadDataHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Prepare the form data
-	r.ParseMultipartForm(32 << 21) // 128MB of ram max
-	if err := r.ParseForm(); err != nil {
+	err = r.ParseMultipartForm(32 << 21) // 128MB of ram max
+	if err != nil {
+		log.Printf(err.Error())
+		errorPage(w, r, http.StatusBadRequest, err.Error())
+		return
+	}
+	if err = r.ParseForm(); err != nil {
 		log.Printf("%s: ParseForm() error: %v\n", pageName, err)
 		errorPage(w, r, http.StatusInternalServerError, err.Error())
 		return
@@ -5210,11 +5226,10 @@ func uploadDataHandler(w http.ResponseWriter, r *http.Request) {
 	// Grab and validate the supplied "public" form field
 	var accessType com.SetAccessType
 	var public bool
-	val := r.PostFormValue("public")
 	public, err = com.GetPub(r)
 	if err != nil {
 		log.Printf("%s: Error when converting public value to boolean: %v\n", pageName, err)
-		errorPage(w, r, http.StatusBadRequest, fmt.Sprintf("Public value '%v' incorrect", val))
+		errorPage(w, r, http.StatusBadRequest, fmt.Sprintf("Public value '%v' incorrect", html.EscapeString(r.PostFormValue("public"))))
 		return
 	}
 	if public {
@@ -5223,6 +5238,15 @@ func uploadDataHandler(w http.ResponseWriter, r *http.Request) {
 		accessType = com.SetToPrivate
 	}
 
+	// Grab and validate the supplied "live" form field
+	var isLiveDB bool
+	isLiveDB, err = com.GetFormLive(r)
+	if err != nil {
+		log.Printf("%s: Error when converting live value to boolean: %v\n", pageName, err)
+		errorPage(w, r, http.StatusBadRequest, fmt.Sprintf("Live value '%v' incorrect", html.EscapeString(r.PostFormValue("live"))))
+		return
+	}
+
 	// Validate the licence value
 	licenceName, err := com.GetFormLicence(r)
 	if err != nil {
@@ -5302,65 +5326,122 @@ func uploadDataHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Was a user agent part of the request?
+	var userAgent string
+	ua, ok := r.Header["User-Agent"]
+	if ok {
+		userAgent = ua[0]
+	}
+
+	// If this is supposed to be a live database, and the database already exists, error out
+	if isLiveDB && exists {
+		errorPage(w, r, http.StatusConflict, "Can't upload a live database over the top of an existing one of the same name.  If you really want to do that, then delete the old one first")
+		return
+	}
+
 	// Retrieve the commit ID for the head of the specified branch
-	var commitID string
+	var commitID, sha string
+	var numBytes int64
 	createBranch := false
-	if exists {
-		branchList, err := com.GetBranches(dbOwner, dbFolder, dbName)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			errorPage(w, r, http.StatusInternalServerError, err.Error())
-			return
-		}
-		branchEntry, ok := branchList[branchName]
-		if !ok {
-			// The specified branch name doesn't exist, so we'll need to create it
-			createBranch = true
-
-			// We also need a commit ID to branch from, so we use the head commit of the default branch
-			defBranch, err := com.GetDefaultBranchName(dbOwner, dbFolder, dbName)
+	if !isLiveDB {
+		if exists {
+			branchList, err := com.GetBranches(dbOwner, dbFolder, dbName)
 			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
 				errorPage(w, r, http.StatusInternalServerError, err.Error())
 				return
 			}
-			branchEntry, ok = branchList[defBranch]
+			branchEntry, ok := branchList[branchName]
 			if !ok {
-				errorPage(w, r, http.StatusInternalServerError, "Could not retrieve commit info for default branch entry")
-				return
+				// The specified branch name doesn't exist, so we'll need to create it
+				createBranch = true
+
+				// We also need a commit ID to branch from, so we use the head commit of the default branch
+				defBranch, err := com.GetDefaultBranchName(dbOwner, dbFolder, dbName)
+				if err != nil {
+					errorPage(w, r, http.StatusInternalServerError, err.Error())
+					return
+				}
+				branchEntry, ok = branchList[defBranch]
+				if !ok {
+					errorPage(w, r, http.StatusInternalServerError, "Could not retrieve commit info for default branch entry")
+					return
+				}
 			}
+			commitID = branchEntry.Commit
+		}
+
+		// Sanity check the uploaded database, and if ok then add it to the system
+		numBytes, _, sha, err = com.AddDatabase(loggedInUser, dbOwner, dbFolder, dbName, createBranch, branchName,
+			commitID, accessType, licenceName, commitMsg, sourceURL, tempFile, time.Now(), time.Time{},
+			"", "", "", "", nil, "")
+		if err != nil {
+			errorPage(w, r, http.StatusInternalServerError, err.Error())
+			return
 		}
-		commitID = branchEntry.Commit
+
+		// Make a record of the upload
+		err = com.LogUpload(dbOwner, dbFolder, dbName, loggedInUser, r.RemoteAddr, "webui", userAgent, time.Now().UTC(), sha)
+		if err != nil {
+			errorPage(w, r, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		// Log the successful database upload
+		log.Printf("%s: Username: '%s', database '%s%s%s' uploaded', bytes: %v\n", pageName, loggedInUser,
+			com.SanitiseLogString(dbOwner), com.SanitiseLogString(dbFolder), com.SanitiseLogString(dbName), numBytes)
+
+		// As the upload was for a standard database, bounce the user to the database view page for it
+		http.Redirect(w, r, fmt.Sprintf("/%s/%s?branch=%s", html.EscapeString(dbOwner), html.EscapeString(dbName), html.EscapeString(branchName)), http.StatusSeeOther)
+		return
 	}
 
-	// Sanity check the uploaded database, and if ok then add it to the system
-	numBytes, _, sha, err := com.AddDatabase(loggedInUser, dbOwner, dbFolder, dbName, createBranch, branchName,
-		commitID, accessType, licenceName, commitMsg, sourceURL, tempFile, time.Now(), time.Time{},
-		"", "", "", "", nil, "")
+	// ** Live databases **
+
+	// Write the incoming database to a temporary file on disk, and sanity check it
+	var tempDB *os.File
+	numBytes, tempDB, sha, _, err = com.WriteDBtoDisk(loggedInUser, dbOwner, dbFolder, dbName, tempFile)
 	if err != nil {
 		errorPage(w, r, http.StatusInternalServerError, err.Error())
 		return
 	}
+	defer os.Remove(tempDB.Name())
 
-	// Was a user agent part of the request?
-	var userAgent string
-	ua, ok := r.Header["User-Agent"]
-	if ok {
-		userAgent = ua[0]
+	// Rewind the internal cursor in the temporary file back to the start again
+	var newOffset int64
+	newOffset, err = tempDB.Seek(0, 0)
+	if err != nil {
+		log.Printf("Seeking on the temporary file (2nd time) failed: %s", err)
+		return
+	}
+	if newOffset != 0 {
+		err = errors.New("Seeking to start of temporary database file didn't work")
+		log.Println(err)
+		return
 	}
 
-	// Make a record of the upload
-	err = com.LogUpload(dbOwner, dbFolder, dbName, loggedInUser, r.RemoteAddr, "webui", userAgent, time.Now().UTC(), sha)
+	// Store the database in Minio
+	err = com.LiveStoreDatabaseMinio(tempDB, dbOwner, dbName, numBytes)
 	if err != nil {
 		errorPage(w, r, http.StatusInternalServerError, err.Error())
 		return
 	}
 
 	// Log the successful database upload
-	log.Printf("%s: Username: '%s', database '%s%s%s' uploaded', bytes: %v\n", pageName, loggedInUser,
-		com.SanitiseLogString(dbOwner), dbFolder, com.SanitiseLogString(dbName), numBytes)
+	log.Printf("%s: Username: '%s', LIVE database '%s%s%s' uploaded', bytes: %v\n", pageName, loggedInUser,
+		com.SanitiseLogString(dbOwner), com.SanitiseLogString(dbFolder), com.SanitiseLogString(dbName), numBytes)
+
+	// Send a request to the AMQP backend to set up the database there, ready for querying
+	err = com.LiveCreateDB(com.AmqpChan, dbOwner, dbName)
+	if err != nil {
+		log.Println(err)
+		errorPage(w, r, http.StatusInternalServerError, err.Error())
+		return
+	}
 
-	// Database upload succeeded.  Bounce the user to the page for the new upload
-	http.Redirect(w, r, fmt.Sprintf("/%s/%s?branch=%s", dbOwner, dbName, branchName), http.StatusSeeOther)
+	// As the upload was for a live database, bounce the user to their profile page
+	http.Redirect(w, r, fmt.Sprintf("/%s", html.EscapeString(dbOwner)), http.StatusSeeOther)
+	return
 }
 
 // Handles JSON requests from the front end to toggle watching of a database.
diff --git a/webui/pages.go b/webui/pages.go
index 7ebc64555..7be029ca1 100644
--- a/webui/pages.go
+++ b/webui/pages.go
@@ -1927,6 +1927,7 @@ func profilePage(w http.ResponseWriter, r *http.Request, userName string) {
 	var pageData struct {
 		Auth0            com.Auth0Set
 		Meta             com.MetaInfo
+		LiveDBS          []com.LiveDBs
 		PrivateDBs       []com.DBInfo
 		PublicDBs        []com.DBInfo
 		SharedWithOthers []com.ShareDatabasePermissionsOthers
@@ -1983,7 +1984,22 @@ func profilePage(w http.ResponseWriter, r *http.Request, userName string) {
 		return
 	}
 
-	// For each of the databases owned by the user, retrieve any share information
+	// Retrieve the list of live databases created by the user
+	var l []com.DBInfo
+	l, err = com.LiveUserDBs(userName)
+	if err != nil {
+		errorPage(w, r, http.StatusInternalServerError, "Database query failed")
+		return
+	}
+	for _, z := range l {
+		pageData.LiveDBS = append(pageData.LiveDBS, com.LiveDBs{
+			DBOwner:     userName,
+			DBName:      z.Database,
+			DateCreated: z.DateCreated,
+		})
+	}
+
+	// For each of the standard databases owned by the user, retrieve any share information
 	var rawList []com.ShareDatabasePermissionsOthers
 	for _, db := range pageData.PublicDBs {
 		var z com.ShareDatabasePermissionsOthers
@@ -2673,7 +2689,7 @@ func userPage(w http.ResponseWriter, r *http.Request, userName string) {
 		return
 	}
 
-	// Retrieve the details for the user who's page we're looking at
+	// Retrieve the details for the user whose page we're looking at
 	usr, err := com.User(userName)
 	if err != nil {
 		errorPage(w, r, http.StatusInternalServerError, err.Error())
diff --git a/webui/templates/profile.html b/webui/templates/profile.html
index c58262c50..95071ea3d 100644
--- a/webui/templates/profile.html
+++ b/webui/templates/profile.html
@@ -242,12 +242,43 @@ <h4>No databases shared with others yet</h4>
             [[ end ]]
         </div>
     </div>
-
+    [[ if .LiveDBS ]]
+    <div class="row" style="border: 5px dashed #181a9c; margin: 2%; border-radius: 10px">
+        <div class="col-md-12">
+            <div style="text-align: center; font-size: large; font-style: italic; color: #181a9c; margin-top: 1%">Experimental</div>
+            <div class="row">
+                <div class="col-md-3">&nbsp;</div>
+                <div class="col-md-6">
+                    <div style="padding-top: 8px; text-align: center">
+                        <h3 style="display: inline; vertical-align: middle;">Live databases (write enabled)</h3>
+                        <br />
+                        <h4 style="vertical-align: middle;"><a class="blackLink" href="https://api.dbhub.io">Access via API only (to start with)</a></h4>
+                    </div>
+                </div>
+                <div class="col-md-3">&nbsp;</div>
+            </div>
+            <div class="row">
+                <div class="col-md-3">&nbsp;</div>
+                <div class="col-md-6">
+                    <table class="table table-striped table-responsive profileTable" data-cy="livedbstbl">
+                        <tr ng-repeat="row in livedbs">
+                            <td>
+                                <h4>{{ row.owner_name }}/{{ row.database_name }}</h4>
+                            </td>
+                        </tr>
+                    </table>
+                </div>
+                <div class="col-md-3">&nbsp;</div>
+            </div>
+        </div>
+    </div>
+    [[ end ]]
 </div>
 [[ template "footer" . ]]
 <script>
     let app = angular.module('DBHub', ['ui.bootstrap', 'ngSanitize']);
     app.controller('profileView', function($scope) {
+        $scope.livedbs = [[ .LiveDBS ]];
         $scope.meta = { Owner: "[[ .Meta.Owner ]]" };
         $scope.pubdb = { Databases: [[ .PublicDBs ]] };
         $scope.privdb = { Databases: [[ .PrivateDBs ]] };
diff --git a/webui/templates/upload.html b/webui/templates/upload.html
index 5c6211ffa..8ddf4329f 100644
--- a/webui/templates/upload.html
+++ b/webui/templates/upload.html
@@ -68,7 +68,7 @@ <h4 style="text-align: center;">
                 </table>
                 <uib-accordion>
                     <div uib-accordion-group class="panel-default" heading="Advanced" is-open="false">
-                        <table class="table table-striped table-responsive settingsTable" width="100%">
+                        <table class="table table-striped table-responsive settingsTable" style="width: 100%">
                             <tr>
                                 <td style="vertical-align: middle; width: 160px; border-left: none;">
                                     <b>Commit Message</b><br /><br />
@@ -103,6 +103,23 @@ <h4 style="text-align: center;">
                                 </td>
                             </tr>
                         </table>
+                        <div class="row" style="border: 5px dashed #181a9c; margin: 2%; border-radius: 10px">
+                            <div class="col-md-12">
+                                <div style="text-align: center; font-size: large; font-style: italic; color: #181a9c; margin-top: 1%">Experimental</div>
+                                <table class="table table-striped table-responsive settingsTable">
+                                    <tr>
+                                        <th style="vertical-align: middle; width: 33%">Live database? (not version controlled)</th>
+                                        <td>
+                                            <div class="btn-group">
+                                                <label class="btn btn-default" ng-model="radioLive" ng-click="liveClick('false')" uib-btn-radio="'false'" data-cy="livebtn">Standard</label>
+                                                <label class="btn btn-default" ng-model="radioLive" ng-click="liveClick('true')" uib-btn-radio="'true'" data-cy="livebtn">Live</label>
+                                            </div>
+                                            <span ng-bind-html="liveDesc"></span>
+                                        </td>
+                                    </tr>
+                                </table>
+                            </div>
+                        </div>
                     </div>
                 </uib-accordion>
                 <div style="text-align: center;">
@@ -110,6 +127,7 @@ <h4 style="text-align: center;">
                     <input type="hidden" name="licence" value="{{ Licence }}" data-cy="hidlic">
                     <input type="hidden" name="username" value="[[ .Meta.Owner ]]" data-cy="hidowner">
                     <input type="hidden" name="dbname" value="[[ .Meta.Database ]]" data-cy="hiddbname">
+                    <input type="hidden" name="live" value="{{ radioLive }}" data-cy="hidlive">
                     <input type="submit" class="btn btn-success" value="Upload" data-cy="uploadbtn">
                 </div>
             </form>
@@ -182,6 +200,20 @@ <h4 style="text-align: center;">
             }
         };
         $scope.publicClick($scope.radioPublic);
+
+        // Set the "live database" radio buttons state when the page first loads
+        $scope.liveDesc = "";
+        $scope.radioLive = "false";
+        $scope.liveClick = function(newValue) {
+            if (newValue === "true") {
+                $scope.radioLive = "true";
+                $scope.liveDesc = "&nbsp; Database will be writable (not version controlled).";
+            } else {
+                $scope.radioLive = "false";
+                $scope.liveDesc = "&nbsp; Database will be standard (version controlled).";
+            }
+        };
+        $scope.liveClick($scope.radioLive);
     });
 </script>
 </body>
diff --git a/webui/vis.go b/webui/vis.go
index cb9eab076..053390506 100644
--- a/webui/vis.go
+++ b/webui/vis.go
@@ -251,7 +251,7 @@ func visualisePage(w http.ResponseWriter, r *http.Request) {
 
 			// Automatically run the saved query
 			var data com.SQLiteRecordSet
-			data, err = com.SQLiteRunQueryDefensive(w, r, com.Visualisation, pageData.Meta.Owner, pageData.Meta.Folder, pageData.Meta.Database, commitID, pageData.Meta.LoggedInUser, params.SQL)
+			data, err = com.SQLiteRunQueryDefensive(w, r, com.QuerySourceVisualisation, pageData.Meta.Owner, pageData.Meta.Folder, pageData.Meta.Database, commitID, pageData.Meta.LoggedInUser, params.SQL)
 			if err != nil {
 				errorPage(w, r, http.StatusInternalServerError, err.Error())
 				return
@@ -516,7 +516,7 @@ func visExecuteSQLShared(w http.ResponseWriter, r *http.Request) (data com.SQLit
 	}
 
 	// Run the query
-	data, err = com.SQLiteRunQueryDefensive(w, r, com.Visualisation, dbOwner, dbFolder, dbName, commitID, loggedInUser, decodedStr)
+	data, err = com.SQLiteRunQueryDefensive(w, r, com.QuerySourceVisualisation, dbOwner, dbFolder, dbName, commitID, loggedInUser, decodedStr)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		fmt.Fprint(w, err)
@@ -728,7 +728,7 @@ func visSave(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Run the visualisation query, to make sure it returns valid data
-	visData, err := com.SQLiteRunQueryDefensive(w, r, com.Visualisation, dbOwner, dbFolder, dbName, commitID, loggedInUser, decodedStr)
+	visData, err := com.SQLiteRunQueryDefensive(w, r, com.QuerySourceVisualisation, dbOwner, dbFolder, dbName, commitID, loggedInUser, decodedStr)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		fmt.Fprintf(w, "%s", err.Error())