diff --git a/bindings/rust/s2n-tls-hyper/src/connector.rs b/bindings/rust/s2n-tls-hyper/src/connector.rs
index f39133ed6d7..ea5670d62f0 100644
--- a/bindings/rust/s2n-tls-hyper/src/connector.rs
+++ b/bindings/rust/s2n-tls-hyper/src/connector.rs
@@ -12,7 +12,6 @@ use s2n_tls::{config::Config, connection};
 use s2n_tls_tokio::TlsConnector;
 use std::{
     future::Future,
-    marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
@@ -25,110 +24,49 @@ use tower_service::Service;
 /// which sends and receives requests over TCP. The `HttpsConnector` struct wraps an HTTP connector,
 /// and uses it to negotiate TLS when the HTTPS scheme is in use.
 #[derive(Clone)]
-pub struct HttpsConnector<Http, ConnBuilder = Config> {
+pub struct HttpsConnector<Http, Builder = Config> {
     http: Http,
-    conn_builder: ConnBuilder,
-    with_insecure_http: bool,
+    conn_builder: Builder,
 }
 
-impl<ConnBuilder> HttpsConnector<HttpConnector, ConnBuilder>
+impl<Builder> HttpsConnector<HttpConnector, Builder>
 where
-    ConnBuilder: connection::Builder,
-    <ConnBuilder as connection::Builder>::Output: Unpin,
+    Builder: connection::Builder,
+    <Builder as connection::Builder>::Output: Unpin,
 {
-    /// Creates a new `HttpsConnector` with the default configuration. Use `HttpsConnector::builder`
-    /// instead to configure an `HttpsConnector`.
-    ///
-    /// `conn_builder` will be used to produce the s2n-tls Connections used for negotiating HTTPS,
-    /// which can be an `s2n_tls::config::Config` or other `s2n_tls::connection::Builder`.
-    ///
-    /// ```
-    /// use s2n_tls_hyper::connector::HttpsConnector;
-    /// use s2n_tls::config::Config;
-    ///
-    /// // Create a new HttpsConnector.
-    /// let connector = HttpsConnector::new(Config::default());
-    /// ```
-    ///
-    /// Note that s2n-tls-hyper will override the ALPN extension to negotiate HTTP. Any ALPN values
-    /// configured on `conn_builder` with APIs like
-    /// `s2n_tls::config::Builder::set_application_protocol_preference()` will be ignored.
-    pub fn new(conn_builder: ConnBuilder) -> HttpsConnector<HttpConnector, ConnBuilder> {
-        HttpsConnector::builder().build(conn_builder)
-    }
-}
-
-impl<HttpConnector, ConnBuilder> HttpsConnector<HttpConnector, ConnBuilder>
-where
-    ConnBuilder: connection::Builder,
-    <ConnBuilder as connection::Builder>::Output: Unpin,
-{
-    /// Creates a `Builder` to configure a new `HttpsConnector`.
-    ///
-    /// ```
-    /// use s2n_tls_hyper::connector::HttpsConnector;
-    /// use s2n_tls::config::Config;
-    ///
-    /// // Create and configure a builder.
-    /// let builder = HttpsConnector::builder();
-    ///
-    /// // Build a new HttpsConnector.
-    /// let connector = builder.build(Config::default());
-    /// ```
-    pub fn builder() -> Builder<HttpConnector, ConnBuilder> {
-        Builder {
-            http: PhantomData,
-            conn_builder: PhantomData,
-            with_insecure_http: false,
-        }
-    }
-}
-
-/// Builder used to configure an `HttpsConnector`. Create a new Builder with
-/// `HttpsConnector::builder`.
-pub struct Builder<Http, ConnBuilder> {
-    http: PhantomData<Http>,
-    conn_builder: PhantomData<ConnBuilder>,
-    with_insecure_http: bool,
-}
-
-impl<ConnBuilder> Builder<HttpConnector, ConnBuilder> {
-    /// Builds a new `HttpsConnector`.
+    /// Creates a new `HttpsConnector`.
     ///
     /// `conn_builder` will be used to produce the s2n-tls Connections used for negotiating HTTPS,
     /// which can be an `s2n_tls::config::Config` or other `s2n_tls::connection::Builder`.
     ///
     /// This API creates an `HttpsConnector` using the default hyper `HttpConnector`. To use an
-    /// existing HTTP connector, use `Builder::build_with_http()`.
+    /// existing HTTP connector, use `HttpsConnector::new_with_http()`.
     ///
     /// Note that s2n-tls-hyper will override the ALPN extension to negotiate HTTP. Any ALPN values
     /// configured on `conn_builder` with APIs like
     /// `s2n_tls::config::Builder::set_application_protocol_preference()` will be ignored.
-    pub fn build(self, conn_builder: ConnBuilder) -> HttpsConnector<HttpConnector, ConnBuilder> {
+    pub fn new(conn_builder: Builder) -> HttpsConnector<HttpConnector, Builder> {
         let mut http = HttpConnector::new();
 
         // By default, the `HttpConnector` only allows the HTTP URI scheme to be used. To negotiate
         // HTTP over TLS via the HTTPS scheme, `enforce_http` must be disabled.
         http.enforce_http(false);
 
-        self.build_with_http(http, conn_builder)
+        Self { http, conn_builder }
     }
 }
 
-impl<Http, ConnBuilder> Builder<Http, ConnBuilder> {
-    /// Allows communication with insecure HTTP endpoints in addition to secure HTTPS endpoints.
-    pub fn with_insecure_http(&mut self) -> &mut Self {
-        self.with_insecure_http = true;
-        self
-    }
-
-    /// Builds a new `HttpsConnector`.
+impl<Http, Builder> HttpsConnector<Http, Builder>
+where
+    Builder: connection::Builder,
+    <Builder as connection::Builder>::Output: Unpin,
+{
+    /// Creates a new `HttpsConnector`.
     ///
     /// `conn_builder` will be used to produce the s2n-tls Connections used for negotiating HTTPS,
     /// which can be an `s2n_tls::config::Config` or other `s2n_tls::connection::Builder`.
     ///
-    /// This API allows an `HttpsConnector` to be constructed with an existing HTTP connector, as
-    /// follows:
+    /// This API allows an `HttpsConnector` to be constructed with an existing HTTP connector, as follows:
     /// ```
     /// use s2n_tls_hyper::connector::HttpsConnector;
     /// use s2n_tls::config::Config;
@@ -139,25 +77,16 @@ impl<Http, ConnBuilder> Builder<Http, ConnBuilder> {
     /// // Ensure that the HTTP connector permits the HTTPS scheme.
     /// http.enforce_http(false);
     ///
-    /// let connector = HttpsConnector::builder()
-    ///     .build_with_http(http, Config::default());
+    /// let connector = HttpsConnector::new_with_http(http, Config::default());
     /// ```
     ///
-    /// `Builder::build()` can be used to create the HTTP connector automatically.
+    /// `HttpsConnector::new()` can be used to create the HTTP connector automatically.
     ///
     /// Note that s2n-tls-hyper will override the ALPN extension to negotiate HTTP. Any ALPN values
     /// configured on `conn_builder` with APIs like
     /// `s2n_tls::config::Builder::set_application_protocol_preference()` will be ignored.
-    pub fn build_with_http(
-        self,
-        http: Http,
-        conn_builder: ConnBuilder,
-    ) -> HttpsConnector<Http, ConnBuilder> {
-        HttpsConnector {
-            http,
-            conn_builder,
-            with_insecure_http: self.with_insecure_http,
-        }
+    pub fn new_with_http(http: Http, conn_builder: Builder) -> HttpsConnector<Http, Builder> {
+        Self { http, conn_builder }
     }
 }
 
@@ -167,22 +96,19 @@ impl<Http, ConnBuilder> Builder<Http, ConnBuilder> {
 // https://docs.rs/hyper-util/latest/hyper_util/client/legacy/connect/trait.Connect.html
 //
 // The hyper compatibility traits for `Service::Response` are implemented in `MaybeHttpsStream`.
-impl<Http, ConnBuilder> Service<Uri> for HttpsConnector<Http, ConnBuilder>
+impl<Http, Builder> Service<Uri> for HttpsConnector<Http, Builder>
 where
     Http: Service<Uri>,
     Http::Response: Read + Write + Connection + Unpin + Send + 'static,
     Http::Future: Send + 'static,
     Http::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-    ConnBuilder: connection::Builder + Send + Sync + 'static,
-    <ConnBuilder as connection::Builder>::Output: Unpin + Send,
+    Builder: connection::Builder + Send + Sync + 'static,
+    <Builder as connection::Builder>::Output: Unpin + Send,
 {
-    type Response = MaybeHttpsStream<Http::Response, ConnBuilder>;
+    type Response = MaybeHttpsStream<Http::Response, Builder>;
     type Error = Error;
     type Future = Pin<
-        Box<
-            dyn Future<Output = Result<MaybeHttpsStream<Http::Response, ConnBuilder>, Error>>
-                + Send,
-        >,
+        Box<dyn Future<Output = Result<MaybeHttpsStream<Http::Response, Builder>, Error>> + Send>,
     >;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -254,21 +180,6 @@ mod tests {
     use hyper_util::{client::legacy::Client, rt::TokioExecutor};
     use std::{error::Error as StdError, str::FromStr};
 
-    #[tokio::test]
-    async fn connector_creation() {
-        let config = Config::default();
-        let connector_from_new = HttpsConnector::new(config.clone());
-        let _assert_type: HttpsConnector<HttpConnector, Config> = connector_from_new;
-
-        let connector_from_build = HttpsConnector::builder().build(config.clone());
-        let _assert_type: HttpsConnector<HttpConnector, Config> = connector_from_build;
-
-        let http: u32 = 10;
-        let connect_from_build_with_http =
-            HttpsConnector::builder().build_with_http(http, config.clone());
-        let _assert_type: HttpsConnector<u32, Config> = connect_from_build_with_http;
-    }
-
     #[tokio::test]
     async fn test_unsecure_http() -> Result<(), Box<dyn StdError>> {
         let connector = HttpsConnector::new(Config::default());