Remove polylith/API mode (#2967)

This removes most of the code used for polylith/API mode.

This removes the `/api` internal endpoints entirely. 

Binary size change roughly 5%: 
```
51437560 Feb 13 10:15 dendrite-monolith-server # old
48759008 Feb 13 10:15 dendrite-monolith-server # new
```

18 files changed, 74 insertions, 491 deletions

diff --git a/setup/base/base.go b/setup/base/base.go
index 6ea68119..aabdd793 100644
--- a/setup/base/base.go
+++ b/setup/base/base.go
@@ -17,7 +17,6 @@ package base
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
 	"database/sql"
 	"embed"
 	"encoding/json"
@@ -38,8 +37,6 @@ import (
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"go.uber.org/atomic"
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/h2c"
 
 	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/dendrite/internal/caching"
@@ -53,19 +50,9 @@ import (
 
 	"github.com/sirupsen/logrus"
 
-	appserviceAPI "github.com/matrix-org/dendrite/appservice/api"
-	asinthttp "github.com/matrix-org/dendrite/appservice/inthttp"
-	federationAPI "github.com/matrix-org/dendrite/federationapi/api"
-	federationIntHTTP "github.com/matrix-org/dendrite/federationapi/inthttp"
-	keyserverAPI "github.com/matrix-org/dendrite/keyserver/api"
-	keyinthttp "github.com/matrix-org/dendrite/keyserver/inthttp"
-	roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"
-	rsinthttp "github.com/matrix-org/dendrite/roomserver/inthttp"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/dendrite/setup/jetstream"
 	"github.com/matrix-org/dendrite/setup/process"
-	userapi "github.com/matrix-org/dendrite/userapi/api"
-	userapiinthttp "github.com/matrix-org/dendrite/userapi/inthttp"
 )
 
 //go:embed static/*.gotmpl
@@ -78,7 +65,6 @@ var staticContent embed.FS
 // Must be closed when shutting down.
 type BaseDendrite struct {
 	*process.ProcessContext
-	componentName          string
 	tracerCloser           io.Closer
 	PublicClientAPIMux     *mux.Router
 	PublicFederationAPIMux *mux.Router
@@ -86,12 +72,9 @@ type BaseDendrite struct {
 	PublicMediaAPIMux      *mux.Router
 	PublicWellKnownAPIMux  *mux.Router
 	PublicStaticMux        *mux.Router
-	InternalAPIMux         *mux.Router
 	DendriteAdminMux       *mux.Router
 	SynapseAdminMux        *mux.Router
 	NATS                   *jetstream.NATSInstance
-	UseHTTPAPIs            bool
-	apiHttpClient          *http.Client
 	Cfg                    *config.Dendrite
 	Caches                 *caching.Caches
 	DNSCache               *gomatrixserverlib.DNSCache
@@ -105,38 +88,26 @@ type BaseDendrite struct {
 const NoListener = ""
 
 const HTTPServerTimeout = time.Minute * 5
-const HTTPClientTimeout = time.Second * 30
 
 type BaseDendriteOptions int
 
 const (
 	DisableMetrics BaseDendriteOptions = iota
-	UseHTTPAPIs
-	PolylithMode
 )
 
 // NewBaseDendrite creates a new instance to be used by a component.
-// The componentName is used for logging purposes, and should be a friendly name
-// of the compontent running, e.g. "SyncAPI"
-func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...BaseDendriteOptions) *BaseDendrite {
+func NewBaseDendrite(cfg *config.Dendrite, options ...BaseDendriteOptions) *BaseDendrite {
 	platformSanityChecks()
-	useHTTPAPIs := false
 	enableMetrics := true
-	isMonolith := true
 	for _, opt := range options {
 		switch opt {
 		case DisableMetrics:
 			enableMetrics = false
-		case UseHTTPAPIs:
-			useHTTPAPIs = true
-		case PolylithMode:
-			isMonolith = false
-			useHTTPAPIs = true
 		}
 	}
 
 	configErrors := &config.ConfigErrors{}
-	cfg.Verify(configErrors, isMonolith)
+	cfg.Verify(configErrors)
 	if len(*configErrors) > 0 {
 		for _, err := range *configErrors {
 			logrus.Errorf("Configuration error: %s", err)
@@ -145,7 +116,7 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
 	}
 
 	internal.SetupStdLogging()
-	internal.SetupHookLogging(cfg.Logging, componentName)
+	internal.SetupHookLogging(cfg.Logging)
 	internal.SetupPprof()
 
 	logrus.Infof("Dendrite version %s", internal.VersionString())
@@ -154,14 +125,13 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
 		logrus.Warn("Open registration is enabled")
 	}
 
-	closer, err := cfg.SetupTracing("Dendrite" + componentName)
+	closer, err := cfg.SetupTracing()
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to start opentracing")
 	}
 
 	var fts *fulltext.Search
-	isSyncOrMonolith := componentName == "syncapi" || isMonolith
-	if cfg.SyncAPI.Fulltext.Enabled && isSyncOrMonolith {
+	if cfg.SyncAPI.Fulltext.Enabled {
 		fts, err = fulltext.New(cfg.SyncAPI.Fulltext)
 		if err != nil {
 			logrus.WithError(err).Panicf("failed to create full text")
@@ -196,32 +166,12 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
 		)
 	}
 
-	apiClient := http.Client{
-		Timeout: time.Minute * 10,
-		Transport: &http2.Transport{
-			AllowHTTP: true,
-			DialTLS: func(network, addr string, _ *tls.Config) (net.Conn, error) {
-				// Ordinarily HTTP/2 would expect TLS, but the remote listener is
-				// H2C-enabled (HTTP/2 without encryption). Overriding the DialTLS
-				// function with a plain Dial allows us to trick the HTTP client
-				// into establishing a HTTP/2 connection without TLS.
-				// TODO: Eventually we will want to look at authenticating and
-				// encrypting these internal HTTP APIs, at which point we will have
-				// to reconsider H2C and change all this anyway.
-				return net.Dial(network, addr)
-			},
-		},
-	}
-
 	// If we're in monolith mode, we'll set up a global pool of database
 	// connections. A component is welcome to use this pool if they don't
 	// have a separate database config of their own.
 	var db *sql.DB
 	var writer sqlutil.Writer
 	if cfg.Global.DatabaseOptions.ConnectionString != "" {
-		if !isMonolith {
-			logrus.Panic("Using a global database connection pool is not supported in polylith deployments")
-		}
 		if cfg.Global.DatabaseOptions.ConnectionString.IsSQLite() {
 			logrus.Panic("Using a global database connection pool is not supported with SQLite databases")
 		}
@@ -246,8 +196,6 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
 
 	return &BaseDendrite{
 		ProcessContext:         process.NewProcessContext(),
-		componentName:          componentName,
-		UseHTTPAPIs:            useHTTPAPIs,
 		tracerCloser:           closer,
 		Cfg:                    cfg,
 		Caches:                 caching.NewRistrettoCache(cfg.Global.Cache.EstimatedMaxSize, cfg.Global.Cache.MaxAge, enableMetrics),
@@ -258,11 +206,9 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
 		PublicMediaAPIMux:      mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicMediaPathPrefix).Subrouter().UseEncodedPath(),
 		PublicWellKnownAPIMux:  mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicWellKnownPrefix).Subrouter().UseEncodedPath(),
 		PublicStaticMux:        mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicStaticPath).Subrouter().UseEncodedPath(),
-		InternalAPIMux:         mux.NewRouter().SkipClean(true).PathPrefix(httputil.InternalPathPrefix).Subrouter().UseEncodedPath(),
 		DendriteAdminMux:       mux.NewRouter().SkipClean(true).PathPrefix(httputil.DendriteAdminPathPrefix).Subrouter().UseEncodedPath(),
 		SynapseAdminMux:        mux.NewRouter().SkipClean(true).PathPrefix(httputil.SynapseAdminPathPrefix).Subrouter().UseEncodedPath(),
 		NATS:                   &jetstream.NATSInstance{},
-		apiHttpClient:          &apiClient,
 		Database:               db,     // set if monolith with global connection pool only
 		DatabaseWriter:         writer, // set if monolith with global connection pool only
 		EnableMetrics:          enableMetrics,
@@ -300,52 +246,6 @@ func (b *BaseDendrite) DatabaseConnection(dbProperties *config.DatabaseOptions,
 	return nil, nil, fmt.Errorf("no database connections configured")
 }
 
-// AppserviceHTTPClient returns the AppServiceInternalAPI for hitting the appservice component over HTTP.
-func (b *BaseDendrite) AppserviceHTTPClient() appserviceAPI.AppServiceInternalAPI {
-	a, err := asinthttp.NewAppserviceClient(b.Cfg.AppServiceURL(), b.apiHttpClient)
-	if err != nil {
-		logrus.WithError(err).Panic("CreateHTTPAppServiceAPIs failed")
-	}
-	return a
-}
-
-// RoomserverHTTPClient returns RoomserverInternalAPI for hitting the roomserver over HTTP.
-func (b *BaseDendrite) RoomserverHTTPClient() roomserverAPI.RoomserverInternalAPI {
-	rsAPI, err := rsinthttp.NewRoomserverClient(b.Cfg.RoomServerURL(), b.apiHttpClient, b.Caches)
-	if err != nil {
-		logrus.WithError(err).Panic("RoomserverHTTPClient failed", b.apiHttpClient)
-	}
-	return rsAPI
-}
-
-// UserAPIClient returns UserInternalAPI for hitting the userapi over HTTP.
-func (b *BaseDendrite) UserAPIClient() userapi.UserInternalAPI {
-	userAPI, err := userapiinthttp.NewUserAPIClient(b.Cfg.UserAPIURL(), b.apiHttpClient)
-	if err != nil {
-		logrus.WithError(err).Panic("UserAPIClient failed", b.apiHttpClient)
-	}
-	return userAPI
-}
-
-// FederationAPIHTTPClient returns FederationInternalAPI for hitting
-// the federation API server over HTTP
-func (b *BaseDendrite) FederationAPIHTTPClient() federationAPI.FederationInternalAPI {
-	f, err := federationIntHTTP.NewFederationAPIClient(b.Cfg.FederationAPIURL(), b.apiHttpClient, b.Caches)
-	if err != nil {
-		logrus.WithError(err).Panic("FederationAPIHTTPClient failed", b.apiHttpClient)
-	}
-	return f
-}
-
-// KeyServerHTTPClient returns KeyInternalAPI for hitting the key server over HTTP
-func (b *BaseDendrite) KeyServerHTTPClient() keyserverAPI.KeyInternalAPI {
-	f, err := keyinthttp.NewKeyServerClient(b.Cfg.KeyServerURL(), b.apiHttpClient)
-	if err != nil {
-		logrus.WithError(err).Panic("KeyServerHTTPClient failed", b.apiHttpClient)
-	}
-	return f
-}
-
 // PushGatewayHTTPClient returns a new client for interacting with (external) Push Gateways.
 func (b *BaseDendrite) PushGatewayHTTPClient() pushgateway.Client {
 	return pushgateway.NewHTTPClient(b.Cfg.UserAPI.PushGatewayDisableTLSValidation)
@@ -442,20 +342,18 @@ func (b *BaseDendrite) ConfigureAdminEndpoints() {
 	})
 }
 
-// SetupAndServeHTTP sets up the HTTP server to serve endpoints registered on
-// ApiMux under /api/ and adds a prometheus handler under /metrics.
+// SetupAndServeHTTP sets up the HTTP server to serve client & federation APIs
+// and adds a prometheus handler under /_dendrite/metrics.
 func (b *BaseDendrite) SetupAndServeHTTP(
-	internalHTTPAddr, externalHTTPAddr config.HTTPAddress,
+	externalHTTPAddr config.HTTPAddress,
 	certFile, keyFile *string,
 ) {
 	// Manually unlocked right before actually serving requests,
 	// as we don't return from this method (defer doesn't work).
 	b.startupLock.Lock()
-	internalAddr, _ := internalHTTPAddr.Address()
 	externalAddr, _ := externalHTTPAddr.Address()
 
 	externalRouter := mux.NewRouter().SkipClean(true).UseEncodedPath()
-	internalRouter := externalRouter
 
 	externalServ := &http.Server{
 		Addr:         string(externalAddr),
@@ -465,25 +363,6 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 			return b.ProcessContext.Context()
 		},
 	}
-	internalServ := externalServ
-
-	if internalAddr != NoListener && externalAddr != internalAddr {
-		// H2C allows us to accept HTTP/2 connections without TLS
-		// encryption. Since we don't currently require any form of
-		// authentication or encryption on these internal HTTP APIs,
-		// H2C gives us all of the advantages of HTTP/2 (such as
-		// stream multiplexing and avoiding head-of-line blocking)
-		// without enabling TLS.
-		internalH2S := &http2.Server{}
-		internalRouter = mux.NewRouter().SkipClean(true).UseEncodedPath()
-		internalServ = &http.Server{
-			Addr:    string(internalAddr),
-			Handler: h2c.NewHandler(internalRouter, internalH2S),
-			BaseContext: func(_ net.Listener) context.Context {
-				return b.ProcessContext.Context()
-			},
-		}
-	}
 
 	b.configureHTTPErrors()
 
@@ -492,9 +371,8 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 		http.Redirect(w, r, httputil.PublicStaticPath, http.StatusFound)
 	})
 
-	internalRouter.PathPrefix(httputil.InternalPathPrefix).Handler(b.InternalAPIMux)
 	if b.Cfg.Global.Metrics.Enabled {
-		internalRouter.Handle("/metrics", httputil.WrapHandlerInBasicAuth(promhttp.Handler(), b.Cfg.Global.Metrics.BasicAuth))
+		externalRouter.Handle("/metrics", httputil.WrapHandlerInBasicAuth(promhttp.Handler(), b.Cfg.Global.Metrics.BasicAuth))
 	}
 
 	b.ConfigureAdminEndpoints()
@@ -528,7 +406,7 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 		})
 		federationHandler = sentryHandler.Handle(b.PublicFederationAPIMux)
 	}
-	internalRouter.PathPrefix(httputil.DendriteAdminPathPrefix).Handler(b.DendriteAdminMux)
+	externalRouter.PathPrefix(httputil.DendriteAdminPathPrefix).Handler(b.DendriteAdminMux)
 	externalRouter.PathPrefix(httputil.PublicClientPathPrefix).Handler(clientHandler)
 	if !b.Cfg.Global.DisableFederation {
 		externalRouter.PathPrefix(httputil.PublicKeyPathPrefix).Handler(b.PublicKeyAPIMux)
@@ -540,38 +418,11 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 	externalRouter.PathPrefix(httputil.PublicStaticPath).Handler(b.PublicStaticMux)
 
 	b.startupLock.Unlock()
-	if internalAddr != NoListener && internalAddr != externalAddr {
-		go func() {
-			var internalShutdown atomic.Bool // RegisterOnShutdown can be called more than once
-			logrus.Infof("Starting internal %s listener on %s", b.componentName, internalServ.Addr)
-			b.ProcessContext.ComponentStarted()
-			internalServ.RegisterOnShutdown(func() {
-				if internalShutdown.CompareAndSwap(false, true) {
-					b.ProcessContext.ComponentFinished()
-					logrus.Infof("Stopped internal HTTP listener")
-				}
-			})
-			if certFile != nil && keyFile != nil {
-				if err := internalServ.ListenAndServeTLS(*certFile, *keyFile); err != nil {
-					if err != http.ErrServerClosed {
-						logrus.WithError(err).Fatal("failed to serve HTTPS")
-					}
-				}
-			} else {
-				if err := internalServ.ListenAndServe(); err != nil {
-					if err != http.ErrServerClosed {
-						logrus.WithError(err).Fatal("failed to serve HTTP")
-					}
-				}
-			}
-			logrus.Infof("Stopped internal %s listener on %s", b.componentName, internalServ.Addr)
-		}()
-	}
 
 	if externalAddr != NoListener {
 		go func() {
 			var externalShutdown atomic.Bool // RegisterOnShutdown can be called more than once
-			logrus.Infof("Starting external %s listener on %s", b.componentName, externalServ.Addr)
+			logrus.Infof("Starting external listener on %s", externalServ.Addr)
 			b.ProcessContext.ComponentStarted()
 			externalServ.RegisterOnShutdown(func() {
 				if externalShutdown.CompareAndSwap(false, true) {
@@ -592,7 +443,7 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 					}
 				}
 			}
-			logrus.Infof("Stopped external %s listener on %s", b.componentName, externalServ.Addr)
+			logrus.Infof("Stopped external listener on %s", externalServ.Addr)
 		}()
 	}
 
@@ -600,7 +451,6 @@ func (b *BaseDendrite) SetupAndServeHTTP(
 	<-b.ProcessContext.WaitForShutdown()
 
 	logrus.Infof("Stopping HTTP listeners")
-	_ = internalServ.Shutdown(context.Background())
 	_ = externalServ.Shutdown(context.Background())
 	logrus.Infof("Stopped HTTP listeners")
 }
diff --git a/setup/base/base_test.go b/setup/base/base_test.go
index 61cb530a..d906294c 100644
--- a/setup/base/base_test.go
+++ b/setup/base/base_test.go
@@ -35,7 +35,7 @@ func TestLandingPage(t *testing.T) {
 	s.Close()
 
 	// start base with the listener and wait for it to be started
-	go b.SetupAndServeHTTP("", config.HTTPAddress(s.URL), nil, nil)
+	go b.SetupAndServeHTTP(config.HTTPAddress(s.URL), nil, nil)
 	time.Sleep(time.Millisecond * 10)
 
 	// When hitting /, we should be redirected to /_matrix/static, which should contain the landing page
diff --git a/setup/config/config.go b/setup/config/config.go
index 2b38cd51..84876616 100644
--- a/setup/config/config.go
+++ b/setup/config/config.go
@@ -79,8 +79,6 @@ type Dendrite struct {
 
 	// Any information derived from the configuration options for later use.
 	Derived Derived `yaml:"-"`
-
-	IsMonolith bool `yaml:"-"`
 }
 
 // TODO: Kill Derived
@@ -114,15 +112,6 @@ type Derived struct {
 	// servers from creating RoomIDs in exclusive application service namespaces
 }
 
-type InternalAPIOptions struct {
-	Listen  HTTPAddress `yaml:"listen"`
-	Connect HTTPAddress `yaml:"connect"`
-}
-
-type ExternalAPIOptions struct {
-	Listen HTTPAddress `yaml:"listen"`
-}
-
 // A Path on the filesystem.
 type Path string
 
@@ -191,7 +180,7 @@ type ConfigErrors []string
 
 // Load a yaml config file for a server run as multiple processes or as a monolith.
 // Checks the config to ensure that it is valid.
-func Load(configPath string, monolith bool) (*Dendrite, error) {
+func Load(configPath string) (*Dendrite, error) {
 	configData, err := os.ReadFile(configPath)
 	if err != nil {
 		return nil, err
@@ -202,28 +191,26 @@ func Load(configPath string, monolith bool) (*Dendrite, error) {
 	}
 	// Pass the current working directory and os.ReadFile so that they can
 	// be mocked in the tests
-	return loadConfig(basePath, configData, os.ReadFile, monolith)
+	return loadConfig(basePath, configData, os.ReadFile)
 }
 
 func loadConfig(
 	basePath string,
 	configData []byte,
 	readFile func(string) ([]byte, error),
-	monolithic bool,
 ) (*Dendrite, error) {
 	var c Dendrite
 	c.Defaults(DefaultOpts{
-		Generate:   false,
-		Monolithic: monolithic,
+		Generate:       false,
+		SingleDatabase: true,
 	})
-	c.IsMonolith = monolithic
 
 	var err error
 	if err = yaml.Unmarshal(configData, &c); err != nil {
 		return nil, err
 	}
 
-	if err = c.check(monolithic); err != nil {
+	if err = c.check(); err != nil {
 		return nil, err
 	}
 
@@ -333,8 +320,8 @@ func (config *Dendrite) Derive() error {
 }
 
 type DefaultOpts struct {
-	Generate   bool
-	Monolithic bool
+	Generate       bool
+	SingleDatabase bool
 }
 
 // SetDefaults sets default config values if they are not explicitly set.
@@ -355,9 +342,9 @@ func (c *Dendrite) Defaults(opts DefaultOpts) {
 	c.Wiring()
 }
 
-func (c *Dendrite) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *Dendrite) Verify(configErrs *ConfigErrors) {
 	type verifiable interface {
-		Verify(configErrs *ConfigErrors, isMonolith bool)
+		Verify(configErrs *ConfigErrors)
 	}
 	for _, c := range []verifiable{
 		&c.Global, &c.ClientAPI, &c.FederationAPI,
@@ -365,7 +352,7 @@ func (c *Dendrite) Verify(configErrs *ConfigErrors, isMonolith bool) {
 		&c.SyncAPI, &c.UserAPI,
 		&c.AppServiceAPI, &c.RelayAPI, &c.MSCs,
 	} {
-		c.Verify(configErrs, isMonolith)
+		c.Verify(configErrs)
 	}
 }
 
@@ -415,14 +402,6 @@ func checkNotEmpty(configErrs *ConfigErrors, key, value string) {
 	}
 }
 
-// checkNotZero verifies the given value is not zero in the configuration.
-// If it is, adds an error to the list.
-func checkNotZero(configErrs *ConfigErrors, key string, value int64) {
-	if value == 0 {
-		configErrs.Add(fmt.Sprintf("missing config key %q", key))
-	}
-}
-
 // checkPositive verifies the given value is positive (zero included)
 // in the configuration. If it is not, adds an error to the list.
 func checkPositive(configErrs *ConfigErrors, key string, value int64) {
@@ -431,26 +410,6 @@ func checkPositive(configErrs *ConfigErrors, key string, value int64) {
 	}
 }
 
-// checkURL verifies that the parameter is a valid URL
-func checkURL(configErrs *ConfigErrors, key, value string) {
-	if value == "" {
-		configErrs.Add(fmt.Sprintf("missing config key %q", key))
-		return
-	}
-	url, err := url.Parse(value)
-	if err != nil {
-		configErrs.Add(fmt.Sprintf("config key %q contains invalid URL (%s)", key, err.Error()))
-		return
-	}
-	switch url.Scheme {
-	case "http":
-	case "https":
-	default:
-		configErrs.Add(fmt.Sprintf("config key %q URL should be http:// or https://", key))
-		return
-	}
-}
-
 // checkLogging verifies the parameters logging.* are valid.
 func (config *Dendrite) checkLogging(configErrs *ConfigErrors) {
 	for _, logrusHook := range config.Logging {
@@ -461,7 +420,7 @@ func (config *Dendrite) checkLogging(configErrs *ConfigErrors) {
 
 // check returns an error type containing all errors found within the config
 // file.
-func (config *Dendrite) check(_ bool) error { // monolithic
+func (config *Dendrite) check() error { // monolithic
 	var configErrs ConfigErrors
 
 	if config.Version != Version {
@@ -528,58 +487,13 @@ func readKeyPEM(path string, data []byte, enforceKeyIDFormat bool) (gomatrixserv
 	}
 }
 
-// AppServiceURL returns a HTTP URL for where the appservice component is listening.
-func (config *Dendrite) AppServiceURL() string {
-	// Hard code the appservice server to talk HTTP for now.
-	// If we support HTTPS we need to think of a practical way to do certificate validation.
-	// People setting up servers shouldn't need to get a certificate valid for the public
-	// internet for an internal API.
-	return string(config.AppServiceAPI.InternalAPI.Connect)
-}
-
-// FederationAPIURL returns an HTTP URL for where the federation API is listening.
-func (config *Dendrite) FederationAPIURL() string {
-	// Hard code the federationapi to talk HTTP for now.
-	// If we support HTTPS we need to think of a practical way to do certificate validation.
-	// People setting up servers shouldn't need to get a certificate valid for the public
-	// internet for an internal API.
-	return string(config.FederationAPI.InternalAPI.Connect)
-}
-
-// RoomServerURL returns an HTTP URL for where the roomserver is listening.
-func (config *Dendrite) RoomServerURL() string {
-	// Hard code the roomserver to talk HTTP for now.
-	// If we support HTTPS we need to think of a practical way to do certificate validation.
-	// People setting up servers shouldn't need to get a certificate valid for the public
-	// internet for an internal API.
-	return string(config.RoomServer.InternalAPI.Connect)
-}
-
-// UserAPIURL returns an HTTP URL for where the userapi is listening.
-func (config *Dendrite) UserAPIURL() string {
-	// Hard code the userapi to talk HTTP for now.
-	// If we support HTTPS we need to think of a practical way to do certificate validation.
-	// People setting up servers shouldn't need to get a certificate valid for the public
-	// internet for an internal API.
-	return string(config.UserAPI.InternalAPI.Connect)
-}
-
-// KeyServerURL returns an HTTP URL for where the key server is listening.
-func (config *Dendrite) KeyServerURL() string {
-	// Hard code the key server to talk HTTP for now.
-	// If we support HTTPS we need to think of a practical way to do certificate validation.
-	// People setting up servers shouldn't need to get a certificate valid for the public
-	// internet for an internal API.
-	return string(config.KeyServer.InternalAPI.Connect)
-}
-
 // SetupTracing configures the opentracing using the supplied configuration.
-func (config *Dendrite) SetupTracing(serviceName string) (closer io.Closer, err error) {
+func (config *Dendrite) SetupTracing() (closer io.Closer, err error) {
 	if !config.Tracing.Enabled {
 		return io.NopCloser(bytes.NewReader([]byte{})), nil
 	}
 	return config.Tracing.Jaeger.InitGlobalTracer(
-		serviceName,
+		"Dendrite",
 		jaegerconfig.Logger(logrusLogger{logrus.StandardLogger()}),
 		jaegerconfig.Metrics(jaegermetrics.NullFactory),
 	)
diff --git a/setup/config/config_appservice.go b/setup/config/config_appservice.go
index bd21826f..37e20a97 100644
--- a/setup/config/config_appservice.go
+++ b/setup/config/config_appservice.go
@@ -22,15 +22,13 @@ import (
 	"strings"
 
 	log "github.com/sirupsen/logrus"
-	yaml "gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v2"
 )
 
 type AppServiceAPI struct {
 	Matrix  *Global  `yaml:"-"`
 	Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-
 	// DisableTLSValidation disables the validation of X.509 TLS certs
 	// on appservice endpoints. This is not recommended in production!
 	DisableTLSValidation bool `yaml:"disable_tls_validation"`
@@ -39,18 +37,9 @@ type AppServiceAPI struct {
 }
 
 func (c *AppServiceAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7777"
-		c.InternalAPI.Connect = "http://localhost:7777"
-	}
 }
 
-func (c *AppServiceAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
-	checkURL(configErrs, "app_service_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "app_service_api.internal_api.connect", string(c.InternalAPI.Connect))
+func (c *AppServiceAPI) Verify(configErrs *ConfigErrors) {
 }
 
 // ApplicationServiceNamespace is the namespace that a specific application
diff --git a/setup/config/config_clientapi.go b/setup/config/config_clientapi.go
index 1deba6bb..b6c74a75 100644
--- a/setup/config/config_clientapi.go
+++ b/setup/config/config_clientapi.go
@@ -9,9 +9,6 @@ type ClientAPI struct {
 	Matrix  *Global  `yaml:"-"`
 	Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
-
 	// If set disables new users from registering (except via shared
 	// secrets)
 	RegistrationDisabled bool `yaml:"registration_disabled"`
@@ -58,11 +55,6 @@ type ClientAPI struct {
 }
 
 func (c *ClientAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7771"
-		c.InternalAPI.Connect = "http://localhost:7771"
-		c.ExternalAPI.Listen = "http://[::]:8071"
-	}
 	c.RegistrationSharedSecret = ""
 	c.RecaptchaPublicKey = ""
 	c.RecaptchaPrivateKey = ""
@@ -74,7 +66,7 @@ func (c *ClientAPI) Defaults(opts DefaultOpts) {
 	c.RateLimiting.Defaults()
 }
 
-func (c *ClientAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *ClientAPI) Verify(configErrs *ConfigErrors) {
 	c.TURN.Verify(configErrs)
 	c.RateLimiting.Verify(configErrs)
 	if c.RecaptchaEnabled {
@@ -108,12 +100,6 @@ func (c *ClientAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
 			)
 		}
 	}
-	if isMonolith { // polylith required configs below
-		return
-	}
-	checkURL(configErrs, "client_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "client_api.internal_api.connect", string(c.InternalAPI.Connect))
-	checkURL(configErrs, "client_api.external_api.listen", string(c.ExternalAPI.Listen))
 }
 
 type TURN struct {
diff --git a/setup/config/config_federationapi.go b/setup/config/config_federationapi.go
index cd7d9056..8c1540b5 100644
--- a/setup/config/config_federationapi.go
+++ b/setup/config/config_federationapi.go
@@ -1,13 +1,12 @@
 package config
 
-import "github.com/matrix-org/gomatrixserverlib"
+import (
+	"github.com/matrix-org/gomatrixserverlib"
+)
 
 type FederationAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
-
 	// The database stores information used by the federation destination queues to
 	// send transactions to remote servers.
 	Database DatabaseOptions `yaml:"database,omitempty"`
@@ -42,12 +41,6 @@ type FederationAPI struct {
 }
 
 func (c *FederationAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7772"
-		c.InternalAPI.Connect = "http://localhost:7772"
-		c.ExternalAPI.Listen = "http://[::]:8072"
-		c.Database.Defaults(10)
-	}
 	c.FederationMaxRetries = 16
 	c.P2PFederationRetriesUntilAssumedOffline = 1
 	c.DisableTLSValidation = false
@@ -68,22 +61,16 @@ func (c *FederationAPI) Defaults(opts DefaultOpts) {
 				},
 			},
 		}
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:federationapi.db"
 		}
 	}
 }
 
-func (c *FederationAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *FederationAPI) Verify(configErrs *ConfigErrors) {
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "federation_api.database.connection_string", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "federation_api.external_api.listen", string(c.ExternalAPI.Listen))
-	checkURL(configErrs, "federation_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "federation_api.internal_api.connect", string(c.InternalAPI.Connect))
 }
 
 // The config for setting a proxy to use for server->server requests
diff --git a/setup/config/config_global.go b/setup/config/config_global.go
index 804eb1a2..ed980afa 100644
--- a/setup/config/config_global.go
+++ b/setup/config/config_global.go
@@ -38,7 +38,6 @@ type Global struct {
 	// component does not specify any database options of its own, then this pool of
 	// connections will be used instead. This way we don't have to manage connection
 	// counts on a per-component basis, but can instead do it for the entire monolith.
-	// In a polylith deployment, this will be ignored.
 	DatabaseOptions DatabaseOptions `yaml:"database,omitempty"`
 
 	// The server name to delegate server-server communications to, with optional port
@@ -93,7 +92,7 @@ func (c *Global) Defaults(opts DefaultOpts) {
 		}
 	}
 	c.KeyValidityPeriod = time.Hour * 24 * 7
-	if opts.Monolithic {
+	if opts.SingleDatabase {
 		c.DatabaseOptions.Defaults(90)
 	}
 	c.JetStream.Defaults(opts)
@@ -105,7 +104,7 @@ func (c *Global) Defaults(opts DefaultOpts) {
 	c.Cache.Defaults()
 }
 
-func (c *Global) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *Global) Verify(configErrs *ConfigErrors) {
 	checkNotEmpty(configErrs, "global.server_name", string(c.ServerName))
 	checkNotEmpty(configErrs, "global.private_key", string(c.PrivateKeyPath))
 
@@ -113,13 +112,13 @@ func (c *Global) Verify(configErrs *ConfigErrors, isMonolith bool) {
 		v.Verify(configErrs)
 	}
 
-	c.JetStream.Verify(configErrs, isMonolith)
-	c.Metrics.Verify(configErrs, isMonolith)
-	c.Sentry.Verify(configErrs, isMonolith)
-	c.DNSCache.Verify(configErrs, isMonolith)
-	c.ServerNotices.Verify(configErrs, isMonolith)
-	c.ReportStats.Verify(configErrs, isMonolith)
-	c.Cache.Verify(configErrs, isMonolith)
+	c.JetStream.Verify(configErrs)
+	c.Metrics.Verify(configErrs)
+	c.Sentry.Verify(configErrs)
+	c.DNSCache.Verify(configErrs)
+	c.ServerNotices.Verify(configErrs)
+	c.ReportStats.Verify(configErrs)
+	c.Cache.Verify(configErrs)
 }
 
 func (c *Global) IsLocalServerName(serverName gomatrixserverlib.ServerName) bool {
@@ -267,7 +266,7 @@ func (c *Metrics) Defaults(opts DefaultOpts) {
 	}
 }
 
-func (c *Metrics) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *Metrics) Verify(configErrs *ConfigErrors) {
 }
 
 // ServerNotices defines the configuration used for sending server notices
@@ -293,7 +292,7 @@ func (c *ServerNotices) Defaults(opts DefaultOpts) {
 	}
 }
 
-func (c *ServerNotices) Verify(errors *ConfigErrors, isMonolith bool) {}
+func (c *ServerNotices) Verify(errors *ConfigErrors) {}
 
 type Cache struct {
 	EstimatedMaxSize DataUnit      `yaml:"max_size_estimated"`
@@ -305,7 +304,7 @@ func (c *Cache) Defaults() {
 	c.MaxAge = time.Hour
 }
 
-func (c *Cache) Verify(errors *ConfigErrors, isMonolith bool) {
+func (c *Cache) Verify(errors *ConfigErrors) {
 	checkPositive(errors, "max_size_estimated", int64(c.EstimatedMaxSize))
 }
 
@@ -323,7 +322,7 @@ func (c *ReportStats) Defaults() {
 	c.Endpoint = "https://matrix.org/report-usage-stats/push"
 }
 
-func (c *ReportStats) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *ReportStats) Verify(configErrs *ConfigErrors) {
 	if c.Enabled {
 		checkNotEmpty(configErrs, "global.report_stats.endpoint", c.Endpoint)
 	}
@@ -344,7 +343,7 @@ func (c *Sentry) Defaults() {
 	c.Enabled = false
 }
 
-func (c *Sentry) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *Sentry) Verify(configErrs *ConfigErrors) {
 }
 
 type DatabaseOptions struct {
@@ -364,8 +363,7 @@ func (c *DatabaseOptions) Defaults(conns int) {
 	c.ConnMaxLifetimeSeconds = -1
 }
 
-func (c *DatabaseOptions) Verify(configErrs *ConfigErrors, isMonolith bool) {
-}
+func (c *DatabaseOptions) Verify(configErrs *ConfigErrors) {}
 
 // MaxIdleConns returns maximum idle connections to the DB
 func (c DatabaseOptions) MaxIdleConns() int {
@@ -397,7 +395,7 @@ func (c *DNSCacheOptions) Defaults() {
 	c.CacheLifetime = time.Minute * 5
 }
 
-func (c *DNSCacheOptions) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *DNSCacheOptions) Verify(configErrs *ConfigErrors) {
 	checkPositive(configErrs, "cache_size", int64(c.CacheSize))
 	checkPositive(configErrs, "cache_lifetime", int64(c.CacheLifetime))
 }
diff --git a/setup/config/config_jetstream.go b/setup/config/config_jetstream.go
index ef8bf014..b8abed25 100644
--- a/setup/config/config_jetstream.go
+++ b/setup/config/config_jetstream.go
@@ -41,11 +41,4 @@ func (c *JetStream) Defaults(opts DefaultOpts) {
 	}
 }
 
-func (c *JetStream) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
-	// If we are running in a polylith deployment then we need at least
-	// one NATS JetStream server to talk to.
-	checkNotZero(configErrs, "global.jetstream.addresses", int64(len(c.Addresses)))
-}
+func (c *JetStream) Verify(configErrs *ConfigErrors) {}
diff --git a/setup/config/config_keyserver.go b/setup/config/config_keyserver.go
index dca9ca9f..64710d95 100644
--- a/setup/config/config_keyserver.go
+++ b/setup/config/config_keyserver.go
@@ -3,31 +3,19 @@ package config
 type KeyServer struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-
 	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
 func (c *KeyServer) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7779"
-		c.InternalAPI.Connect = "http://localhost:7779"
-		c.Database.Defaults(10)
-	}
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:keyserver.db"
 		}
 	}
 }
 
-func (c *KeyServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *KeyServer) Verify(configErrs *ConfigErrors) {
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "key_server.database.connection_string", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "key_server.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "key_server.internal_api.connect", string(c.InternalAPI.Connect))
 }
diff --git a/setup/config/config_mediaapi.go b/setup/config/config_mediaapi.go
index 53a8219e..030bc375 100644
--- a/setup/config/config_mediaapi.go
+++ b/setup/config/config_mediaapi.go
@@ -7,9 +7,6 @@ import (
 type MediaAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
-
 	// The MediaAPI database stores information about files uploaded and downloaded
 	// by local users. It is only accessed by the MediaAPI.
 	Database DatabaseOptions `yaml:"database,omitempty"`
@@ -39,12 +36,6 @@ type MediaAPI struct {
 var DefaultMaxFileSizeBytes = FileSizeBytes(10485760)
 
 func (c *MediaAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7774"
-		c.InternalAPI.Connect = "http://localhost:7774"
-		c.ExternalAPI.Listen = "http://[::]:8074"
-		c.Database.Defaults(5)
-	}
 	c.MaxFileSizeBytes = DefaultMaxFileSizeBytes
 	c.MaxThumbnailGenerators = 10
 	if opts.Generate {
@@ -65,14 +56,14 @@ func (c *MediaAPI) Defaults(opts DefaultOpts) {
 				ResizeMethod: "scale",
 			},
 		}
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:mediaapi.db"
 		}
 		c.BasePath = "./media_store"
 	}
 }
 
-func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *MediaAPI) Verify(configErrs *ConfigErrors) {
 	checkNotEmpty(configErrs, "media_api.base_path", string(c.BasePath))
 	checkPositive(configErrs, "media_api.max_file_size_bytes", int64(c.MaxFileSizeBytes))
 	checkPositive(configErrs, "media_api.max_thumbnail_generators", int64(c.MaxThumbnailGenerators))
@@ -81,13 +72,8 @@ func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
 		checkPositive(configErrs, fmt.Sprintf("media_api.thumbnail_sizes[%d].width", i), int64(size.Width))
 		checkPositive(configErrs, fmt.Sprintf("media_api.thumbnail_sizes[%d].height", i), int64(size.Height))
 	}
-	if isMonolith { // polylith required configs below
-		return
-	}
+
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "media_api.database.connection_string", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "media_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "media_api.internal_api.connect", string(c.InternalAPI.Connect))
-	checkURL(configErrs, "media_api.external_api.listen", string(c.ExternalAPI.Listen))
 }
diff --git a/setup/config/config_mscs.go b/setup/config/config_mscs.go
index 6d5ff39a..21d4b4da 100644
--- a/setup/config/config_mscs.go
+++ b/setup/config/config_mscs.go
@@ -14,11 +14,8 @@ type MSCs struct {
 }
 
 func (c *MSCs) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.Database.Defaults(5)
-	}
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:mscs.db"
 		}
 	}
@@ -34,10 +31,7 @@ func (c *MSCs) Enabled(msc string) bool {
 	return false
 }
 
-func (c *MSCs) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *MSCs) Verify(configErrs *ConfigErrors) {
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "mscs.database.connection_string", string(c.Database.ConnectionString))
 	}
diff --git a/setup/config/config_relayapi.go b/setup/config/config_relayapi.go
index 5a6b093d..ba7b7808 100644
--- a/setup/config/config_relayapi.go
+++ b/setup/config/config_relayapi.go
@@ -17,36 +17,21 @@ package config
 type RelayAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
-
 	// The database stores information used by the relay queue to
 	// forward transactions to remote servers.
 	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
 func (c *RelayAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7775"
-		c.InternalAPI.Connect = "http://localhost:7775"
-		c.ExternalAPI.Listen = "http://[::]:8075"
-		c.Database.Defaults(10)
-	}
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:relayapi.db"
 		}
 	}
 }
 
-func (c *RelayAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *RelayAPI) Verify(configErrs *ConfigErrors) {
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "relay_api.database.connection_string", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "relay_api.external_api.listen", string(c.ExternalAPI.Listen))
-	checkURL(configErrs, "relay_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "relay_api.internal_api.connect", string(c.InternalAPI.Connect))
 }
diff --git a/setup/config/config_roomserver.go b/setup/config/config_roomserver.go
index 5e3b7f2e..319c2419 100644
--- a/setup/config/config_roomserver.go
+++ b/setup/config/config_roomserver.go
@@ -3,31 +3,19 @@ package config
 type RoomServer struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-
 	Database DatabaseOptions `yaml:"database,omitempty"`
 }
 
 func (c *RoomServer) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7770"
-		c.InternalAPI.Connect = "http://localhost:7770"
-		c.Database.Defaults(20)
-	}
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:roomserver.db"
 		}
 	}
 }
 
-func (c *RoomServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *RoomServer) Verify(configErrs *ConfigErrors) {
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "room_server.database.connection_string", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "room_server.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "room_server.internal_ap.connect", string(c.InternalAPI.Connect))
 }
diff --git a/setup/config/config_syncapi.go b/setup/config/config_syncapi.go
index a87da373..756f4cfb 100644
--- a/setup/config/config_syncapi.go
+++ b/setup/config/config_syncapi.go
@@ -3,9 +3,6 @@ package config
 type SyncAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-	ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
-
 	Database DatabaseOptions `yaml:"database,omitempty"`
 
 	RealIPHeader string `yaml:"real_ip_header"`
@@ -14,31 +11,19 @@ type SyncAPI struct {
 }
 
 func (c *SyncAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7773"
-		c.InternalAPI.Connect = "http://localhost:7773"
-		c.ExternalAPI.Listen = "http://localhost:8073"
-		c.Database.Defaults(20)
-	}
 	c.Fulltext.Defaults(opts)
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.Database.ConnectionString = "file:syncapi.db"
 		}
 	}
 }
 
-func (c *SyncAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
-	c.Fulltext.Verify(configErrs, isMonolith)
-	if isMonolith { // polylith required configs below
-		return
-	}
+func (c *SyncAPI) Verify(configErrs *ConfigErrors) {
+	c.Fulltext.Verify(configErrs)
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "sync_api.database", string(c.Database.ConnectionString))
 	}
-	checkURL(configErrs, "sync_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "sync_api.internal_api.connect", string(c.InternalAPI.Connect))
-	checkURL(configErrs, "sync_api.external_api.listen", string(c.ExternalAPI.Listen))
 }
 
 type Fulltext struct {
@@ -54,7 +39,7 @@ func (f *Fulltext) Defaults(opts DefaultOpts) {
 	f.Language = "en"
 }
 
-func (f *Fulltext) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (f *Fulltext) Verify(configErrs *ConfigErrors) {
 	if !f.Enabled {
 		return
 	}
diff --git a/setup/config/config_test.go b/setup/config/config_test.go
index ffbf4c3c..79407f30 100644
--- a/setup/config/config_test.go
+++ b/setup/config/config_test.go
@@ -30,14 +30,13 @@ func TestLoadConfigRelative(t *testing.T) {
 			"/my/config/dir/matrix_key.pem": testKey,
 			"/my/config/dir/tls_cert.pem":   testCert,
 		}.readFile,
-		false,
 	)
 	if err != nil {
 		t.Error("failed to load config:", err)
 	}
 
 	configErrors := &ConfigErrors{}
-	cfg.Verify(configErrors, false)
+	cfg.Verify(configErrors)
 	if len(*configErrors) > 0 {
 		for _, err := range *configErrors {
 			logrus.Errorf("Configuration error: %s", err)
@@ -81,9 +80,6 @@ global:
   jetstream:
     addresses: ["test"]
 app_service_api:
-  internal_api:
-    listen: http://localhost:7777
-    connect: http://localhost:7777
   database:
     connection_string: file:appservice.db
     max_open_conns: 100
@@ -91,11 +87,6 @@ app_service_api:
     conn_max_lifetime: -1
   config_files: []
 client_api:
-  internal_api:
-    listen: http://localhost:7771
-    connect: http://localhost:7771
-  external_api:
-    listen: http://[::]:8071
   registration_disabled: true
   registration_shared_secret: ""
   enable_registration_captcha: false
@@ -109,38 +100,16 @@ client_api:
     turn_shared_secret: ""
     turn_username: ""
     turn_password: ""
-current_state_server:
-  internal_api:
-    listen: http://localhost:7782
-    connect: http://localhost:7782
-  database:
-    connection_string: file:currentstate.db
-    max_open_conns: 100
-    max_idle_conns: 2
-    conn_max_lifetime: -1
 federation_api:
-  internal_api:
-    listen: http://localhost:7772
-    connect: http://localhost:7772
-  external_api:
-    listen: http://[::]:8072
   database:
     connection_string: file:federationapi.db
 key_server:
-  internal_api:
-    listen: http://localhost:7779
-    connect: http://localhost:7779
   database:
     connection_string: file:keyserver.db
     max_open_conns: 100
     max_idle_conns: 2
     conn_max_lifetime: -1
 media_api:
-  internal_api:
-    listen: http://localhost:7774
-    connect: http://localhost:7774
-  external_api:
-    listen: http://[::]:8074
   database:
     connection_string: file:mediaapi.db
     max_open_conns: 100
@@ -161,18 +130,12 @@ media_api:
     height: 480
     method: scale
 room_server:
-  internal_api:
-    listen: http://localhost:7770
-    connect: http://localhost:7770
   database:
     connection_string: file:roomserver.db
     max_open_conns: 100
     max_idle_conns: 2
     conn_max_lifetime: -1
 server_key_api:
-  internal_api:
-    listen: http://localhost:7780
-    connect: http://localhost:7780
   database:
     connection_string: file:serverkeyapi.db
     max_open_conns: 100
@@ -186,18 +149,12 @@ server_key_api:
     - key_id: ed25519:a_RXGa
       public_key: l8Hft5qXKn1vfHrg3p4+W8gELQVo8N13JkluMfmn2sQ
 sync_api:
-  internal_api:
-    listen: http://localhost:7773
-    connect: http://localhost:7773
   database:
     connection_string: file:syncapi.db
     max_open_conns: 100
     max_idle_conns: 2
     conn_max_lifetime: -1
 user_api:
-  internal_api:
-    listen: http://localhost:7781
-    connect: http://localhost:7781
   account_database:
     connection_string: file:userapi_accounts.db
     max_open_conns: 100
@@ -209,11 +166,6 @@ user_api:
     max_idle_conns: 2
     conn_max_lifetime: -1
 relay_api:
-  internal_api:
-    listen: http://localhost:7775
-    connect: http://localhost:7775
-  external_api:
-    listen: http://[::]:8075
   database:
     connection_string: file:relayapi.db
 mscs:
diff --git a/setup/config/config_userapi.go b/setup/config/config_userapi.go
index f8ad41d9..e64a3910 100644
--- a/setup/config/config_userapi.go
+++ b/setup/config/config_userapi.go
@@ -5,8 +5,6 @@ import "golang.org/x/crypto/bcrypt"
 type UserAPI struct {
 	Matrix *Global `yaml:"-"`
 
-	InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
-
 	// The cost when hashing passwords.
 	BCryptCost int `yaml:"bcrypt_cost"`
 
@@ -28,28 +26,18 @@ type UserAPI struct {
 const DefaultOpenIDTokenLifetimeMS = 3600000 // 60 minutes
 
 func (c *UserAPI) Defaults(opts DefaultOpts) {
-	if !opts.Monolithic {
-		c.InternalAPI.Listen = "http://localhost:7781"
-		c.InternalAPI.Connect = "http://localhost:7781"
-		c.AccountDatabase.Defaults(10)
-	}
 	c.BCryptCost = bcrypt.DefaultCost
 	c.OpenIDTokenLifetimeMS = DefaultOpenIDTokenLifetimeMS
 	if opts.Generate {
-		if !opts.Monolithic {
+		if !opts.SingleDatabase {
 			c.AccountDatabase.ConnectionString = "file:userapi_accounts.db"
 		}
 	}
 }
 
-func (c *UserAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
+func (c *UserAPI) Verify(configErrs *ConfigErrors) {
 	checkPositive(configErrs, "user_api.openid_token_lifetime_ms", c.OpenIDTokenLifetimeMS)
-	if isMonolith { // polylith required configs below
-		return
-	}
 	if c.Matrix.DatabaseOptions.ConnectionString == "" {
 		checkNotEmpty(configErrs, "user_api.account_database.connection_string", string(c.AccountDatabase.ConnectionString))
 	}
-	checkURL(configErrs, "user_api.internal_api.listen", string(c.InternalAPI.Listen))
-	checkURL(configErrs, "user_api.internal_api.connect", string(c.InternalAPI.Connect))
 }
diff --git a/setup/flags.go b/setup/flags.go
index a9dac61a..869caa28 100644
--- a/setup/flags.go
+++ b/setup/flags.go
@@ -43,7 +43,7 @@ func ParseFlags(monolith bool) *config.Dendrite {
 		logrus.Fatal("--config must be supplied")
 	}
 
-	cfg, err := config.Load(*configPath, monolith)
+	cfg, err := config.Load(*configPath)
 
 	if err != nil {
 		logrus.Fatalf("Invalid config file: %s", err)
diff --git a/setup/mscs/msc2836/msc2836_test.go b/setup/mscs/msc2836/msc2836_test.go
index 0388fcc5..f12fbbfc 100644
--- a/setup/mscs/msc2836/msc2836_test.go
+++ b/setup/mscs/msc2836/msc2836_test.go
@@ -499,7 +499,7 @@ func assertUnsignedChildren(t *testing.T, ev gomatrixserverlib.ClientEvent, relT
 }
 
 type testUserAPI struct {
-	userapi.UserInternalAPITrace
+	userapi.UserInternalAPI
 	accessTokens map[string]userapi.Device
 }
 
@@ -516,7 +516,7 @@ func (u *testUserAPI) QueryAccessToken(ctx context.Context, req *userapi.QueryAc
 type testRoomserverAPI struct {
 	// use a trace API as it implements method stubs so we don't need to have them here.
 	// We'll override the functions we care about.
-	roomserver.RoomserverInternalAPITrace
+	roomserver.RoomserverInternalAPI
 	userToJoinedRooms map[string][]string
 	events            map[string]*gomatrixserverlib.HeaderedEvent
 }
@@ -548,8 +548,8 @@ func injectEvents(t *testing.T, userAPI userapi.UserInternalAPI, rsAPI roomserve
 	t.Helper()
 	cfg := &config.Dendrite{}
 	cfg.Defaults(config.DefaultOpts{
-		Generate:   true,
-		Monolithic: true,
+		Generate:       true,
+		SingleDatabase: true,
 	})
 	cfg.Global.ServerName = "localhost"
 	cfg.MSCs.Database.ConnectionString = "file:msc2836_test.db"