diff --git a/clickhouse-admin/src/lib.rs b/clickhouse-admin/src/lib.rs
index 1697d24adc1..76e55e1e2b0 100644
--- a/clickhouse-admin/src/lib.rs
+++ b/clickhouse-admin/src/lib.rs
@@ -7,7 +7,6 @@ use omicron_common::FileKv;
 use slog::{debug, error, Drain};
 use slog_dtrace::ProbeRegistration;
 use slog_error_chain::SlogInlineError;
-use std::error::Error;
 use std::io;
 use std::sync::Arc;
 
@@ -28,7 +27,7 @@ pub enum StartError {
     #[error("failed to register dtrace probes: {0}")]
     RegisterDtraceProbes(String),
     #[error("failed to initialize HTTP server")]
-    InitializeHttpServer(#[source] Box<dyn Error + Send + Sync>),
+    InitializeHttpServer(#[source] dropshot::BuildError),
 }
 
 pub type Server = dropshot::HttpServer<Arc<ServerContext>>;
@@ -64,15 +63,15 @@ pub async fn start_server_admin_server(
             .with_log(log.new(slog::o!("component" => "ClickhouseCli"))),
         log.new(slog::o!("component" => "ServerContext")),
     );
-    let http_server_starter = dropshot::HttpServerStarter::new(
-        &server_config.dropshot,
+
+    dropshot::ServerBuilder::new(
         http_entrypoints::clickhouse_admin_server_api(),
         Arc::new(context),
-        &log.new(slog::o!("component" => "dropshot")),
+        log.new(slog::o!("component" => "dropshot")),
     )
-    .map_err(StartError::InitializeHttpServer)?;
-
-    Ok(http_server_starter.start())
+    .config(server_config.dropshot)
+    .start()
+    .map_err(StartError::InitializeHttpServer)
 }
 
 /// Start the dropshot server for `clickhouse-admin-server` which
@@ -106,13 +105,13 @@ pub async fn start_keeper_admin_server(
             .with_log(log.new(slog::o!("component" => "ClickhouseCli"))),
         log.new(slog::o!("component" => "ServerContext")),
     );
-    let http_server_starter = dropshot::HttpServerStarter::new(
-        &server_config.dropshot,
+
+    dropshot::ServerBuilder::new(
         http_entrypoints::clickhouse_admin_keeper_api(),
         Arc::new(context),
-        &log.new(slog::o!("component" => "dropshot")),
+        log.new(slog::o!("component" => "dropshot")),
     )
-    .map_err(StartError::InitializeHttpServer)?;
-
-    Ok(http_server_starter.start())
+    .config(server_config.dropshot)
+    .start()
+    .map_err(StartError::InitializeHttpServer)
 }
diff --git a/cockroach-admin/src/lib.rs b/cockroach-admin/src/lib.rs
index 10573442979..dbe36358d21 100644
--- a/cockroach-admin/src/lib.rs
+++ b/cockroach-admin/src/lib.rs
@@ -10,7 +10,6 @@ use slog::error;
 use slog::Drain;
 use slog_dtrace::ProbeRegistration;
 use slog_error_chain::SlogInlineError;
-use std::error::Error;
 use std::io;
 use std::sync::Arc;
 
@@ -30,7 +29,7 @@ pub enum StartError {
     #[error("failed to register dtrace probes: {0}")]
     RegisterDtraceProbes(String),
     #[error("failed to initialize HTTP server")]
-    InitializeHttpServer(#[source] Box<dyn Error + Send + Sync>),
+    InitializeHttpServer(#[source] dropshot::BuildError),
 }
 
 pub type Server = dropshot::HttpServer<Arc<ServerContext>>;
@@ -64,13 +63,12 @@ pub async fn start_server(
         cockroach_cli,
         log.new(slog::o!("component" => "ServerContext")),
     );
-    let http_server_starter = dropshot::HttpServerStarter::new(
-        &server_config.dropshot,
+    dropshot::ServerBuilder::new(
         http_entrypoints::api(),
         Arc::new(context),
-        &log.new(slog::o!("component" => "dropshot")),
+        log.new(slog::o!("component" => "dropshot")),
     )
-    .map_err(StartError::InitializeHttpServer)?;
-
-    Ok(http_server_starter.start())
+    .config(server_config.dropshot)
+    .start()
+    .map_err(StartError::InitializeHttpServer)
 }
diff --git a/dns-server/src/lib.rs b/dns-server/src/lib.rs
index 88549e9982d..b851e35541f 100644
--- a/dns-server/src/lib.rs
+++ b/dns-server/src/lib.rs
@@ -80,14 +80,14 @@ pub async fn start_servers(
         let http_api = http_server::api();
         let http_api_context = http_server::Context::new(store);
 
-        dropshot::HttpServerStarter::new(
-            dropshot_config,
+        dropshot::ServerBuilder::new(
             http_api,
             http_api_context,
-            &log.new(o!("component" => "http")),
+            log.new(o!("component" => "http")),
         )
-        .map_err(|error| anyhow!("setting up HTTP server: {:#}", error))?
+        .config(dropshot_config.clone())
         .start()
+        .map_err(|error| anyhow!("setting up HTTP server: {:#}", error))?
     };
 
     Ok((dns_server, dropshot_server))
diff --git a/gateway/src/lib.rs b/gateway/src/lib.rs
index 760857ab311..35eb3dbc791 100644
--- a/gateway/src/lib.rs
+++ b/gateway/src/lib.rs
@@ -87,25 +87,29 @@ fn start_dropshot_server(
     all_servers_shutdown: &FuturesUnordered<ShutdownWaitFuture>,
     log: &Logger,
 ) -> Result<(), String> {
-    let dropshot = ConfigDropshot {
-        bind_address: SocketAddr::V6(addr),
-        request_body_max_bytes,
-        default_handler_task_mode: HandlerTaskMode::Detached,
-        log_headers: vec![],
-    };
-    let http_server_starter = dropshot::HttpServerStarter::new(
-        &dropshot,
-        http_entrypoints::api(),
-        Arc::clone(apictx),
-        &log.new(o!("component" => "dropshot")),
-    )
-    .map_err(|error| {
-        format!("initializing http server listening at {addr}: {}", error)
-    })?;
-
     match http_servers.entry(addr) {
         Entry::Vacant(slot) => {
-            let http_server = http_server_starter.start();
+            let dropshot = ConfigDropshot {
+                bind_address: SocketAddr::V6(addr),
+                request_body_max_bytes,
+                default_handler_task_mode: HandlerTaskMode::Detached,
+                log_headers: vec![],
+            };
+
+            let http_server = dropshot::ServerBuilder::new(
+                http_entrypoints::api(),
+                Arc::clone(apictx),
+                log.new(o!("component" => "dropshot")),
+            )
+            .config(dropshot)
+            .start()
+            .map_err(|error| {
+                format!(
+                    "initializing http server listening at {addr}: {}",
+                    error
+                )
+            })?;
+
             all_servers_shutdown.push(http_server.wait_for_shutdown());
             slot.insert(http_server);
             Ok(())
diff --git a/installinator-api/src/lib.rs b/installinator-api/src/lib.rs
index b42165c31d4..487e5d786c4 100644
--- a/installinator-api/src/lib.rs
+++ b/installinator-api/src/lib.rs
@@ -8,11 +8,11 @@
 //! named by the client, since it is expected that multiple services will
 //! implement it.
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use dropshot::{
     Body, ConfigDropshot, FreeformBody, HandlerTaskMode, HttpError,
-    HttpResponseHeaders, HttpResponseOk, HttpResponseUpdatedNoContent,
-    HttpServerStarter, Path, RequestContext, TypedBody,
+    HttpResponseHeaders, HttpResponseOk, HttpResponseUpdatedNoContent, Path,
+    RequestContext, TypedBody,
 };
 use hyper::{header, StatusCode};
 use installinator_common::EventReport;
@@ -134,36 +134,3 @@ pub fn default_config(bind_address: std::net::SocketAddr) -> ConfigDropshot {
         log_headers: vec![],
     }
 }
-
-/// Make an `HttpServerStarter` for the installinator API with default settings.
-pub fn make_server_starter<T: InstallinatorApi>(
-    context: T::Context,
-    bind_address: std::net::SocketAddr,
-    log: &slog::Logger,
-) -> Result<HttpServerStarter<T::Context>> {
-    let dropshot_config = dropshot::ConfigDropshot {
-        bind_address,
-        // Even though the installinator sets an upper bound on the number
-        // of items in a progress report, they can get pretty large if they
-        // haven't gone through for a bit. Ensure that hitting the max
-        // request size won't cause a failure by setting a generous upper
-        // bound for the request size.
-        //
-        // TODO: replace with an endpoint-specific option once
-        // https://github.com/oxidecomputer/dropshot/pull/618 lands and is
-        // available in omicron.
-        request_body_max_bytes: 4 * 1024 * 1024,
-        default_handler_task_mode: HandlerTaskMode::Detached,
-        log_headers: vec![],
-    };
-
-    let api = crate::installinator_api_mod::api_description::<T>()?;
-    let server =
-        dropshot::HttpServerStarter::new(&dropshot_config, api, context, &log)
-            .map_err(|error| {
-                anyhow!(error)
-                    .context("failed to create installinator artifact server")
-            })?;
-
-    Ok(server)
-}
diff --git a/internal-dns/resolver/src/resolver.rs b/internal-dns/resolver/src/resolver.rs
index 607588270d5..af47bb23adc 100644
--- a/internal-dns/resolver/src/resolver.rs
+++ b/internal-dns/resolver/src/resolver.rs
@@ -816,9 +816,10 @@ mod test {
             bind_address: "[::1]:0".parse().unwrap(),
             ..Default::default()
         };
-        dropshot::HttpServerStarter::new(&config_dropshot, api(), label, &log)
-            .unwrap()
+        dropshot::ServerBuilder::new(api(), label, log)
+            .config(config_dropshot)
             .start()
+            .unwrap()
     }
 
     #[tokio::test]
diff --git a/nexus/src/app/external_endpoints.rs b/nexus/src/app/external_endpoints.rs
index 9d56dad61fe..f837edc4fb0 100644
--- a/nexus/src/app/external_endpoints.rs
+++ b/nexus/src/app/external_endpoints.rs
@@ -1323,14 +1323,9 @@ mod test {
         let logctx = omicron_test_utils::dev::test_setup_log("test_authority");
         let mut api = dropshot::ApiDescription::new();
         api.register(echo_server_name).unwrap();
-        let server = dropshot::HttpServerStarter::new(
-            &dropshot::ConfigDropshot::default(),
-            api,
-            (),
-            &logctx.log,
-        )
-        .expect("failed to create dropshot server")
-        .start();
+        let server = dropshot::ServerBuilder::new(api, (), logctx.log.clone())
+            .start()
+            .expect("failed to create dropshot server");
         let local_addr = server.local_addr();
         let port = local_addr.port();
 
diff --git a/nexus/src/lib.rs b/nexus/src/lib.rs
index 634873ec841..564277ad05e 100644
--- a/nexus/src/lib.rs
+++ b/nexus/src/lib.rs
@@ -83,12 +83,13 @@ impl InternalServer {
         .await?;
 
         // Launch the internal server.
-        let server_starter_internal = match dropshot::HttpServerStarter::new(
-            &config.deployment.dropshot_internal,
+        let http_server_internal = match dropshot::ServerBuilder::new(
             internal_api(),
             context.clone(),
-            &log.new(o!("component" => "dropshot_internal")),
+            log.new(o!("component" => "dropshot_internal")),
         )
+        .config(config.deployment.dropshot_internal.clone())
+        .start()
         .map_err(|error| format!("initializing internal server: {}", error))
         {
             Ok(server) => server,
@@ -97,7 +98,6 @@ impl InternalServer {
                 return Err(err);
             }
         };
-        let http_server_internal = server_starter_internal.start();
 
         Ok(Self {
             apictx: context,
@@ -157,32 +157,30 @@ impl Server {
         };
 
         let http_server_external = {
-            let server_starter_external =
-                dropshot::HttpServerStarter::new_with_tls(
-                    &config.deployment.dropshot_external.dropshot,
-                    external_api(),
-                    apictx.for_external(),
-                    &log.new(o!("component" => "dropshot_external")),
-                    tls_config.clone().map(dropshot::ConfigTls::Dynamic),
-                )
-                .map_err(|error| {
-                    format!("initializing external server: {}", error)
-                })?;
-            server_starter_external.start()
+            dropshot::ServerBuilder::new(
+                external_api(),
+                apictx.for_external(),
+                log.new(o!("component" => "dropshot_external")),
+            )
+            .config(config.deployment.dropshot_external.dropshot.clone())
+            .tls(tls_config.clone().map(dropshot::ConfigTls::Dynamic))
+            .start()
+            .map_err(|error| {
+                format!("initializing external server: {}", error)
+            })?
         };
         let http_server_techport_external = {
-            let server_starter_external_techport =
-                dropshot::HttpServerStarter::new_with_tls(
-                    &techport_server_config,
-                    external_api(),
-                    apictx.for_techport(),
-                    &log.new(o!("component" => "dropshot_external_techport")),
-                    tls_config.map(dropshot::ConfigTls::Dynamic),
-                )
-                .map_err(|error| {
-                    format!("initializing external techport server: {}", error)
-                })?;
-            server_starter_external_techport.start()
+            dropshot::ServerBuilder::new(
+                external_api(),
+                apictx.for_techport(),
+                log.new(o!("component" => "dropshot_external_techport")),
+            )
+            .config(techport_server_config)
+            .tls(tls_config.map(dropshot::ConfigTls::Dynamic))
+            .start()
+            .map_err(|error| {
+                format!("initializing external techport server: {}", error)
+            })?
         };
 
         // Start the metric producer server that oximeter uses to fetch our
diff --git a/oximeter/collector/src/lib.rs b/oximeter/collector/src/lib.rs
index 68fff4cbf0e..ce190e02ed4 100644
--- a/oximeter/collector/src/lib.rs
+++ b/oximeter/collector/src/lib.rs
@@ -10,7 +10,7 @@ use dropshot::ConfigDropshot;
 use dropshot::ConfigLogging;
 use dropshot::HttpError;
 use dropshot::HttpServer;
-use dropshot::HttpServerStarter;
+use dropshot::ServerBuilder;
 use internal_dns_types::names::ServiceName;
 use omicron_common::address::get_internal_dns_server_addresses;
 use omicron_common::address::DNS_PORT;
@@ -311,17 +311,17 @@ impl Oximeter {
         .expect("Expected an infinite retry loop initializing the timeseries database");
 
         let dropshot_log = log.new(o!("component" => "dropshot"));
-        let server = HttpServerStarter::new(
-            &ConfigDropshot {
-                bind_address: SocketAddr::V6(args.address),
-                ..Default::default()
-            },
+        let server = ServerBuilder::new(
             oximeter_api(),
             Arc::clone(&agent),
-            &dropshot_log,
+            dropshot_log,
         )
-        .map_err(|e| Error::Server(e.to_string()))?
-        .start();
+        .config(ConfigDropshot {
+            bind_address: SocketAddr::V6(args.address),
+            ..Default::default()
+        })
+        .start()
+        .map_err(|e| Error::Server(e.to_string()))?;
 
         // Notify Nexus that this oximeter instance is available.
         let our_info = nexus_client::types::OximeterInfo {
@@ -422,17 +422,17 @@ impl Oximeter {
         );
 
         let dropshot_log = log.new(o!("component" => "dropshot"));
-        let server = HttpServerStarter::new(
-            &ConfigDropshot {
-                bind_address: SocketAddr::V6(args.address),
-                ..Default::default()
-            },
+        let server = ServerBuilder::new(
             oximeter_api(),
             Arc::clone(&agent),
-            &dropshot_log,
+            dropshot_log,
         )
-        .map_err(|e| Error::Server(e.to_string()))?
-        .start();
+        .config(ConfigDropshot {
+            bind_address: SocketAddr::V6(args.address),
+            ..Default::default()
+        })
+        .start()
+        .map_err(|e| Error::Server(e.to_string()))?;
         info!(log, "started oximeter standalone server");
 
         // Notify the standalone nexus.
diff --git a/oximeter/collector/src/standalone.rs b/oximeter/collector/src/standalone.rs
index f1558072b68..faa27ce04bd 100644
--- a/oximeter/collector/src/standalone.rs
+++ b/oximeter/collector/src/standalone.rs
@@ -15,8 +15,8 @@ use dropshot::HttpError;
 use dropshot::HttpResponseCreated;
 use dropshot::HttpResponseUpdatedNoContent;
 use dropshot::HttpServer;
-use dropshot::HttpServerStarter;
 use dropshot::RequestContext;
+use dropshot::ServerBuilder;
 use dropshot::TypedBody;
 use nexus_types::internal_api::params::OximeterInfo;
 use omicron_common::api::internal::nexus::ProducerEndpoint;
@@ -216,14 +216,14 @@ impl Server {
         let nexus = Arc::new(StandaloneNexus::new(
             log.new(slog::o!("component" => "nexus-standalone")),
         ));
-        let server = HttpServerStarter::new(
-            &ConfigDropshot { bind_address: address, ..Default::default() },
+        let server = ServerBuilder::new(
             standalone_nexus_api(),
             Arc::clone(&nexus),
-            &log,
+            log.clone(),
         )
-        .map_err(|e| Error::Server(e.to_string()))?
-        .start();
+        .config(ConfigDropshot { bind_address: address, ..Default::default() })
+        .start()
+        .map_err(|e| Error::Server(e.to_string()))?;
         info!(
             log,
             "created standalone nexus server for metric collections";
diff --git a/oximeter/producer/src/lib.rs b/oximeter/producer/src/lib.rs
index 4bde5f69ffb..522ce983b47 100644
--- a/oximeter/producer/src/lib.rs
+++ b/oximeter/producer/src/lib.rs
@@ -12,9 +12,9 @@ use dropshot::ConfigDropshot;
 use dropshot::HttpError;
 use dropshot::HttpResponseOk;
 use dropshot::HttpServer;
-use dropshot::HttpServerStarter;
 use dropshot::Path;
 use dropshot::RequestContext;
+use dropshot::ServerBuilder;
 use internal_dns_resolver::ResolveError;
 use internal_dns_resolver::Resolver;
 use internal_dns_types::names::ServiceName;
@@ -194,14 +194,10 @@ impl Server {
         dropshot: &ConfigDropshot,
     ) -> Result<HttpServer<ProducerRegistry>, Error> {
         let dropshot_log = log.new(o!("component" => "dropshot"));
-        HttpServerStarter::new(
-            dropshot,
-            metric_server_api(),
-            registry.clone(),
-            &dropshot_log,
-        )
-        .map_err(|e| Error::Server(e.to_string()))
-        .map(HttpServerStarter::start)
+        ServerBuilder::new(metric_server_api(), registry.clone(), dropshot_log)
+            .config(dropshot.clone())
+            .start()
+            .map_err(|e| Error::Server(e.to_string()))
     }
 
     // Create a new server registering with Nexus.
@@ -464,8 +460,8 @@ mod tests {
     use dropshot::HttpError;
     use dropshot::HttpResponseCreated;
     use dropshot::HttpServer;
-    use dropshot::HttpServerStarter;
     use dropshot::RequestContext;
+    use dropshot::ServerBuilder;
     use omicron_common::api::internal::nexus::ProducerKind;
     use omicron_common::api::internal::nexus::ProducerRegistrationResponse;
     use omicron_test_utils::dev::poll::{wait_for_condition, CondCheckError};
@@ -510,18 +506,14 @@ mod tests {
     fn spawn_fake_nexus_server(log: &Logger) -> HttpServer<Context> {
         let mut api = ApiDescription::new();
         api.register(register_producer).expect("Expected to register endpoint");
-        HttpServerStarter::new(
-            &ConfigDropshot {
+        ServerBuilder::new(api, Arc::new(AtomicU32::new(0)), log.clone())
+            .config(ConfigDropshot {
                 bind_address: "[::1]:0".parse().unwrap(),
                 request_body_max_bytes: 2048,
                 ..Default::default()
-            },
-            api,
-            Arc::new(AtomicU32::new(0)),
-            log,
-        )
-        .expect("Expected to start Dropshot server")
-        .start()
+            })
+            .start()
+            .expect("Expected to start Dropshot server")
     }
 
     #[tokio::test]
diff --git a/sled-agent/src/artifact_store.rs b/sled-agent/src/artifact_store.rs
index cb6e40044fb..5b78c0099d1 100644
--- a/sled-agent/src/artifact_store.rs
+++ b/sled-agent/src/artifact_store.rs
@@ -23,8 +23,8 @@ use std::time::Duration;
 use camino::{Utf8Path, Utf8PathBuf};
 use camino_tempfile::{NamedUtf8TempFile, Utf8TempPath};
 use dropshot::{
-    Body, ConfigDropshot, FreeformBody, HttpError, HttpResponseOk,
-    HttpServerStarter, Path, RequestContext, StreamingBody,
+    Body, ConfigDropshot, FreeformBody, HttpError, HttpResponseOk, Path,
+    RequestContext, ServerBuilder, StreamingBody,
 };
 use futures::{Stream, TryStreamExt};
 use http::StatusCode;
@@ -130,18 +130,18 @@ impl ArtifactStore<StorageHandle> {
         depot_address.set_port(REPO_DEPOT_PORT);
 
         let log = self.log.new(o!("component" => "dropshot (Repo Depot)"));
-        Ok(HttpServerStarter::new(
-            &ConfigDropshot {
-                bind_address: depot_address.into(),
-                ..dropshot_config.clone()
-            },
+        ServerBuilder::new(
             repo_depot_api_mod::api_description::<RepoDepotImpl>()
                 .expect("registered entrypoints"),
             self,
-            &log,
+            log,
         )
-        .map_err(StartError::Dropshot)?
-        .start())
+        .config(ConfigDropshot {
+            bind_address: depot_address.into(),
+            ..dropshot_config.clone()
+        })
+        .start()
+        .map_err(StartError::Dropshot)
     }
 }
 
@@ -151,7 +151,7 @@ pub enum StartError {
     DatasetConfig(#[source] sled_storage::error::Error),
 
     #[error("Dropshot error while starting Repo Depot service")]
-    Dropshot(#[source] Box<dyn std::error::Error + Send + Sync>),
+    Dropshot(#[source] dropshot::BuildError),
 }
 
 macro_rules! log_and_store {
diff --git a/sled-agent/src/bootstrap/server.rs b/sled-agent/src/bootstrap/server.rs
index d52da69e0e7..cdd09fbbe80 100644
--- a/sled-agent/src/bootstrap/server.rs
+++ b/sled-agent/src/bootstrap/server.rs
@@ -459,16 +459,16 @@ fn start_dropshot_server(
     ));
     let dropshot_log =
         context.base_log.new(o!("component" => "dropshot (BootstrapAgent)"));
-    let http_server = dropshot::HttpServerStarter::new(
-        &dropshot_config,
+    let http_server = dropshot::ServerBuilder::new(
         http_entrypoints::api(),
         context,
-        &dropshot_log,
+        dropshot_log,
     )
+    .config(dropshot_config)
+    .start()
     .map_err(|error| {
         StartError::InitBootstrapDropshotServer(error.to_string())
-    })?
-    .start();
+    })?;
 
     Ok(http_server)
 }
diff --git a/sled-agent/src/fakes/nexus.rs b/sled-agent/src/fakes/nexus.rs
index 1a40dbcfbe3..1efbf695b36 100644
--- a/sled-agent/src/fakes/nexus.rs
+++ b/sled-agent/src/fakes/nexus.rs
@@ -157,9 +157,10 @@ pub fn start_test_server(
         bind_address: "[::1]:0".parse().unwrap(),
         ..Default::default()
     };
-    dropshot::HttpServerStarter::new(&config_dropshot, api(), label, &log)
-        .unwrap()
+    dropshot::ServerBuilder::new(api(), label, log)
+        .config(config_dropshot)
         .start()
+        .unwrap()
 }
 
 /// Creates a transient DNS server pointing to a fake Nexus dropshot server.
diff --git a/sled-agent/src/server.rs b/sled-agent/src/server.rs
index 6709e2d75f9..f60f367d280 100644
--- a/sled-agent/src/server.rs
+++ b/sled-agent/src/server.rs
@@ -70,14 +70,11 @@ impl Server {
             ..config.dropshot.clone()
         };
         let dropshot_log = log.new(o!("component" => "dropshot (SledAgent)"));
-        let http_server = dropshot::HttpServerStarter::new(
-            &dropshot_config,
-            http_api(),
-            sled_agent,
-            &dropshot_log,
-        )
-        .map_err(|error| format!("initializing server: {}", error))?
-        .start();
+        let http_server =
+            dropshot::ServerBuilder::new(http_api(), sled_agent, dropshot_log)
+                .config(dropshot_config)
+                .start()
+                .map_err(|error| format!("initializing server: {}", error))?;
 
         Ok(Server { http_server })
     }
diff --git a/sled-agent/src/sim/server.rs b/sled-agent/src/sim/server.rs
index 3e6b16dcd66..57bfbac760d 100644
--- a/sled-agent/src/sim/server.rs
+++ b/sled-agent/src/sim/server.rs
@@ -99,14 +99,14 @@ impl Server {
         .await;
 
         let dropshot_log = log.new(o!("component" => "dropshot"));
-        let http_server = dropshot::HttpServerStarter::new(
-            &config.dropshot,
+        let http_server = dropshot::ServerBuilder::new(
             http_api(),
             sled_agent.clone(),
-            &dropshot_log,
+            dropshot_log,
         )
-        .map_err(|error| anyhow!("initializing server: {}", error))?
-        .start();
+        .config(config.dropshot.clone())
+        .start()
+        .map_err(|error| anyhow!("initializing server: {}", error))?;
 
         // Notify the control plane that we're up, and continue trying this
         // until it succeeds. We retry with an randomized, capped exponential
diff --git a/sled-agent/src/sim/storage.rs b/sled-agent/src/sim/storage.rs
index 83694996588..bf9ba75a482 100644
--- a/sled-agent/src/sim/storage.rs
+++ b/sled-agent/src/sim/storage.rs
@@ -786,14 +786,14 @@ impl CrucibleServer {
         };
         let dropshot_log = log
             .new(o!("component" => "Simulated CrucibleAgent Dropshot Server"));
-        let server = dropshot::HttpServerStarter::new(
-            &config,
+        let server = dropshot::ServerBuilder::new(
             super::http_entrypoints_storage::api(),
             data.clone(),
-            &dropshot_log,
+            dropshot_log,
         )
-        .expect("Could not initialize server")
-        .start();
+        .config(config)
+        .start()
+        .expect("Could not initialize server");
         info!(&log, "Created Simulated Crucible Server"; "address" => server.local_addr());
 
         CrucibleServer { server, data }
@@ -1453,21 +1453,21 @@ impl PantryServer {
     ) -> Self {
         let pantry = Arc::new(Pantry::new(sled_agent));
 
-        let server = dropshot::HttpServerStarter::new(
-            &dropshot::ConfigDropshot {
-                bind_address: SocketAddr::new(ip, 0),
-                // This has to be large enough to support:
-                // - bulk writes into disks
-                request_body_max_bytes: 8192 * 1024,
-                default_handler_task_mode: HandlerTaskMode::Detached,
-                log_headers: vec![],
-            },
+        let server = dropshot::ServerBuilder::new(
             super::http_entrypoints_pantry::api(),
             pantry.clone(),
-            &log.new(o!("component" => "dropshot")),
+            log.new(o!("component" => "dropshot")),
         )
-        .expect("Could not initialize pantry server")
-        .start();
+        .config(dropshot::ConfigDropshot {
+            bind_address: SocketAddr::new(ip, 0),
+            // This has to be large enough to support:
+            // - bulk writes into disks
+            request_body_max_bytes: 8192 * 1024,
+            default_handler_task_mode: HandlerTaskMode::Detached,
+            log_headers: vec![],
+        })
+        .start()
+        .expect("Could not initialize pantry server");
 
         info!(&log, "Started Simulated Crucible Pantry"; "address" => server.local_addr());
 
diff --git a/wicketd/src/lib.rs b/wicketd/src/lib.rs
index 1ef7df610d9..4292f2e0d76 100644
--- a/wicketd/src/lib.rs
+++ b/wicketd/src/lib.rs
@@ -184,8 +184,7 @@ impl Server {
         let wicketd_server = {
             let ds_log = log.new(o!("component" => "dropshot (wicketd)"));
             let mgs_client = make_mgs_client(log.clone(), args.mgs_address);
-            dropshot::HttpServerStarter::new(
-                &dropshot_config,
+            dropshot::ServerBuilder::new(
                 http_entrypoints::api(),
                 ServerContext {
                     bind_address: args.address,
@@ -200,10 +199,11 @@ impl Server {
                     preflight_checker: PreflightCheckerHandler::new(&log),
                     internal_dns_resolver,
                 },
-                &ds_log,
+                ds_log,
             )
-            .map_err(|err| anyhow!(err).context("initializing http server"))?
+            .config(dropshot_config)
             .start()
+            .map_err(|err| anyhow!(err).context("initializing http server"))?
         };
 
         let installinator_server = {
@@ -215,21 +215,21 @@ impl Server {
                     WicketdInstallinatorApiImpl,
                 >()?;
 
-            dropshot::HttpServerStarter::new(
-                &installinator_config,
+            dropshot::ServerBuilder::new(
                 api_description,
                 WicketdInstallinatorContext::new(
                     &log,
                     store.clone(),
                     ipr_artifact,
                 ),
-                &log,
+                log,
             )
+            .config(installinator_config)
+            .start()
             .map_err(|err| {
                 anyhow!(err)
                     .context("failed to create installinator artifact server")
             })?
-            .start()
         };
 
         Ok(Self {