diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerOperationGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerOperationGenerator.kt
index 3a5af6cb50..2da3c0fcde 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerOperationGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerOperationGenerator.kt
@@ -57,10 +57,6 @@ class ServerOperationGenerator(
 
             impl #{SmithyHttpServer}::operation::OperationShape for $operationName {
                 const ID: #{SmithyHttpServer}::shape_id::ShapeId = #{SmithyHttpServer}::shape_id::ShapeId::new(${operationIdAbsolute.dq()}, ${operationId.namespace.dq()}, ${operationId.name.dq()});
-
-                type Input = crate::input::${operationName}Input;
-                type Output = crate::output::${operationName}Output;
-                type Error = #{Error:W};
             }
 
             impl #{SmithyHttpServer}::instrumentation::sensitivity::Sensitivity for $operationName {
diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerServiceGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerServiceGenerator.kt
index 2b4e2ee2e9..7d3f796d5d 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerServiceGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerServiceGenerator.kt
@@ -39,6 +39,7 @@ class ServerServiceGenerator(
     private val codegenScope =
         arrayOf(
             "Bytes" to RuntimeType.Bytes,
+            "FuturesUtil" to ServerCargoDependency.FuturesUtil.toType(),
             "Http" to RuntimeType.Http,
             "SmithyHttp" to RuntimeType.smithyHttp(runtimeConfig),
             "HttpBody" to RuntimeType.HttpBody,
@@ -129,19 +130,20 @@ class ServerServiceGenerator(
                 ///     /* Set other handlers */
                 ///     .build()
                 ///     .unwrap();
-                /// ## let app: $serviceName<#{SmithyHttpServer}::routing::Route<#{SmithyHttp}::body::SdkBody>> = app;
+                /// ## fn check<S: #{Tower}::Service<#{Http}::Request<#{SmithyHttp}::body::SdkBody>>>(_: S) {}
+                /// ## check(app);
                 /// ```
                 ///
-                pub fn $fieldName<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
+                pub fn $fieldName<Input, HandlerType>(self, handler: HandlerType) -> Self
                 where
-                    HandlerType: #{SmithyHttpServer}::operation::Handler<crate::operation_shape::$structName, HandlerExtractors>,
+                    HandlerType: #{SmithyHttpServer}::operation::Handler<Input>,
 
                     ModelPl: #{SmithyHttpServer}::plugin::Plugin<
                         $serviceName,
                         crate::operation_shape::$structName,
-                        #{SmithyHttpServer}::operation::IntoService<crate::operation_shape::$structName, HandlerType>
+                        #{SmithyHttpServer}::operation::FixInput<Input, #{SmithyHttpServer}::operation::IntoService<HandlerType>>
                     >,
-                    #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>: #{SmithyHttpServer}::plugin::Plugin<
+                    #{SmithyHttpServer}::operation::UpgradePlugin: #{SmithyHttpServer}::plugin::Plugin<
                         $serviceName,
                         crate::operation_shape::$structName,
                         ModelPl::Output
@@ -150,7 +152,7 @@ class ServerServiceGenerator(
                         $serviceName,
                         crate::operation_shape::$structName,
                         <
-                            #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>
+                            #{SmithyHttpServer}::operation::UpgradePlugin
                             as #{SmithyHttpServer}::plugin::Plugin<
                                 $serviceName,
                                 crate::operation_shape::$structName,
@@ -163,13 +165,8 @@ class ServerServiceGenerator(
                     <HttpPl::Output as #{Tower}::Service<#{Http}::Request<Body>>>::Future: Send + 'static,
 
                 {
-                    use #{SmithyHttpServer}::operation::OperationShapeExt;
-                    use #{SmithyHttpServer}::plugin::Plugin;
-                    let svc = crate::operation_shape::$structName::from_handler(handler);
-                    let svc = self.model_plugin.apply(svc);
-                    let svc = #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>::new().apply(svc);
-                    let svc = self.http_plugin.apply(svc);
-                    self.${fieldName}_custom(svc)
+                    let svc = #{SmithyHttpServer}::operation::IntoService::new(handler);
+                    self.${fieldName}_service(svc)
                 }
 
                 /// Sets the [`$structName`](crate::operation_shape::$structName) operation.
@@ -192,19 +189,18 @@ class ServerServiceGenerator(
                 ///     /* Set other handlers */
                 ///     .build()
                 ///     .unwrap();
-                /// ## let app: $serviceName<#{SmithyHttpServer}::routing::Route<#{SmithyHttp}::body::SdkBody>> = app;
+                /// ## fn check<S: #{Tower}::Service<#{Http}::Request<#{SmithyHttp}::body::SdkBody>>>(_: S) {}
+                /// ## check(app);
                 /// ```
                 ///
-                pub fn ${fieldName}_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self
+                pub fn ${fieldName}_service<Input, S>(self, service: S) -> Self
                 where
-                    S: #{SmithyHttpServer}::operation::OperationService<crate::operation_shape::$structName, ServiceExtractors>,
-
                     ModelPl: #{SmithyHttpServer}::plugin::Plugin<
                         $serviceName,
                         crate::operation_shape::$structName,
-                        #{SmithyHttpServer}::operation::Normalize<crate::operation_shape::$structName, S>
+                        #{SmithyHttpServer}::operation::FixInput<Input, S>
                     >,
-                    #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>: #{SmithyHttpServer}::plugin::Plugin<
+                    #{SmithyHttpServer}::operation::UpgradePlugin: #{SmithyHttpServer}::plugin::Plugin<
                         $serviceName,
                         crate::operation_shape::$structName,
                         ModelPl::Output
@@ -213,7 +209,7 @@ class ServerServiceGenerator(
                         $serviceName,
                         crate::operation_shape::$structName,
                         <
-                            #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>
+                            #{SmithyHttpServer}::operation::UpgradePlugin
                             as #{SmithyHttpServer}::plugin::Plugin<
                                 $serviceName,
                                 crate::operation_shape::$structName,
@@ -226,11 +222,10 @@ class ServerServiceGenerator(
                     <HttpPl::Output as #{Tower}::Service<#{Http}::Request<Body>>>::Future: Send + 'static,
 
                 {
-                    use #{SmithyHttpServer}::operation::OperationShapeExt;
                     use #{SmithyHttpServer}::plugin::Plugin;
-                    let svc = crate::operation_shape::$structName::from_service(service);
+                    let svc = #{SmithyHttpServer}::operation::FixInput::new(service);
                     let svc = self.model_plugin.apply(svc);
-                    let svc = #{SmithyHttpServer}::operation::UpgradePlugin::<UpgradeExtractors>::new().apply(svc);
+                    let svc = #{SmithyHttpServer}::operation::UpgradePlugin::new().apply(svc);
                     let svc = self.http_plugin.apply(svc);
                     self.${fieldName}_custom(svc)
                 }
@@ -295,7 +290,13 @@ class ServerServiceGenerator(
             ///
             /// Check out [`$builderName::build_unchecked`] if you'd prefer the service to return status code 500 when an
             /// unspecified route requested.
-            pub fn build(self) -> Result<$serviceName<#{SmithyHttpServer}::routing::Route<$builderBodyGenericTypeName>>, MissingOperationsError>
+            pub fn build(self) -> Result<$serviceName<
+                #{SmithyHttpServer}::routing::RoutingService<
+                    #{Router} <
+                        #{SmithyHttpServer}::routing::Route<$builderBodyGenericTypeName>
+                        >
+                    >
+                >, MissingOperationsError>
             {
                 let router = {
                     use #{SmithyHttpServer}::operation::OperationShape;
@@ -313,7 +314,7 @@ class ServerServiceGenerator(
                     #{Router}::from_iter([#{RoutesArrayElements:W}])
                 };
                 Ok($serviceName {
-                    router: #{SmithyHttpServer}::routing::RoutingService::new(router),
+                    inner: #{SmithyHttpServer}::routing::RoutingService::new(router),
                 })
             }
             """,
@@ -359,7 +360,7 @@ class ServerServiceGenerator(
                     (
                         $requestSpecsModuleName::$specBuilderFunctionName(),
                         self.$fieldName.unwrap_or_else(|| {
-                            let svc = #{SmithyHttpServer}::operation::MissingFailure::<#{Protocol}>::default();
+                            let svc = #{SmithyHttpServer}::operation::MissingFailure::<$serviceName, #{Protocol}>::default();
                             #{SmithyHttpServer}::routing::Route::new(svc)
                         })
                     ),
@@ -376,13 +377,19 @@ class ServerServiceGenerator(
             ///
             /// Check out [`$builderName::build`] if you'd prefer the builder to fail if one or more operations do
             /// not have a registered handler.
-            pub fn build_unchecked(self) -> $serviceName<#{SmithyHttpServer}::routing::Route<$builderBodyGenericTypeName>>
+            pub fn build_unchecked(self) -> $serviceName<
+                #{SmithyHttpServer}::routing::RoutingService<
+                    #{Router} <
+                        #{SmithyHttpServer}::routing::Route<$builderBodyGenericTypeName>
+                        >
+                    >
+                >
             where
                 $builderBodyGenericTypeName: Send + 'static
             {
                 let router = #{Router}::from_iter([#{Pairs:W}]);
                 $serviceName {
-                    router: #{SmithyHttpServer}::routing::RoutingService::new(router),
+                    inner: #{SmithyHttpServer}::routing::RoutingService::new(router),
                 }
             }
             """,
@@ -463,8 +470,8 @@ class ServerServiceGenerator(
             ///
             /// See the [root](crate) documentation for more information.
             ##[derive(Clone)]
-            pub struct $serviceName<S = #{SmithyHttpServer}::routing::Route> {
-                router: #{SmithyHttpServer}::routing::RoutingService<#{Router}<S>, #{Protocol}>,
+            pub struct $serviceName<S = ()> {
+                inner: S,
             }
 
             impl $serviceName<()> {
@@ -498,7 +505,6 @@ class ServerServiceGenerator(
                     #{SmithyHttpServer}::routing::IntoMakeService::new(self)
                 }
 
-
                 /// Converts [`$serviceName`] into a [`MakeService`](tower::make::MakeService) with [`ConnectInfo`](#{SmithyHttpServer}::request::connect_info::ConnectInfo).
                 pub fn into_make_service_with_connect_info<C>(self) -> #{SmithyHttpServer}::routing::IntoMakeServiceWithConnectInfo<Self, C> {
                     #{SmithyHttpServer}::routing::IntoMakeServiceWithConnectInfo::new(self)
@@ -510,7 +516,7 @@ class ServerServiceGenerator(
                     L: #{Tower}::Layer<S>
                 {
                     $serviceName {
-                        router: self.router.map(|s| s.layer(layer))
+                        inner: layer.layer(self.inner)
                     }
                 }
 
@@ -530,22 +536,26 @@ class ServerServiceGenerator(
                 }
             }
 
-            impl<B, RespB, S> #{Tower}::Service<#{Http}::Request<B>> for $serviceName<S>
+            impl<B, S> #{Tower}::Service<#{Http}::Request<B>> for $serviceName<S>
             where
-                S: #{Tower}::Service<#{Http}::Request<B>, Response = #{Http}::Response<RespB>> + Clone,
-                RespB: #{HttpBody}::Body<Data = #{Bytes}> + Send + 'static,
-                RespB::Error: Into<Box<dyn std::error::Error + Send + Sync>>
+                S: #{Tower}::Service<
+                    #{Http}::Request<B>,
+                    Response = #{Http}::Response<#{SmithyHttpServer}::body::BoxBody>
+                > + Clone,
+                S::Error: #{SmithyHttpServer}::response::IntoResponseUniform<<$serviceName as #{SmithyHttpServer}::service::ServiceShape>::Protocol>
             {
-                type Response = #{Http}::Response<#{SmithyHttpServer}::body::BoxBody>;
+                type Response = S::Response;
                 type Error = S::Error;
-                type Future = #{SmithyHttpServer}::routing::RoutingFuture<S, B>;
+                type Future = #{FuturesUtil}::future::Map<S::Future, fn(Result<Self::Response, Self::Error>) -> Result<Self::Response, Self::Error>>;
 
                 fn poll_ready(&mut self, cx: &mut std::task::Context) -> std::task::Poll<Result<(), Self::Error>> {
-                    self.router.poll_ready(cx)
+                    self.inner.poll_ready(cx)
                 }
 
                 fn call(&mut self, request: #{Http}::Request<B>) -> Self::Future {
-                    self.router.call(request)
+                    use #{FuturesUtil}::FutureExt;
+                    use #{SmithyHttpServer}::response::IntoResponseUniform;
+                    self.inner.call(request).map(|result| match result { Ok(ok) => Ok(ok), Err(err) => Ok(err.into_response()) })
                 }
             }
             """,
diff --git a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/protocols/ServerHttpBoundProtocolGenerator.kt b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/protocols/ServerHttpBoundProtocolGenerator.kt
index 6e22828a1c..cf174fd7a5 100644
--- a/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/protocols/ServerHttpBoundProtocolGenerator.kt
+++ b/codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/protocols/ServerHttpBoundProtocolGenerator.kt
@@ -71,6 +71,7 @@ import software.amazon.smithy.rust.codegen.core.util.hasTrait
 import software.amazon.smithy.rust.codegen.core.util.inputShape
 import software.amazon.smithy.rust.codegen.core.util.isStreaming
 import software.amazon.smithy.rust.codegen.core.util.outputShape
+import software.amazon.smithy.rust.codegen.core.util.toPascalCase
 import software.amazon.smithy.rust.codegen.server.smithy.ServerCargoDependency
 import software.amazon.smithy.rust.codegen.server.smithy.ServerCodegenContext
 import software.amazon.smithy.rust.codegen.server.smithy.canReachConstrainedShape
@@ -157,6 +158,7 @@ class ServerHttpBoundProtocolTraitImplGenerator(
     private val runtimeConfig = codegenContext.runtimeConfig
     private val httpBindingResolver = protocol.httpBindingResolver
     private val protocolFunctions = ProtocolFunctions(codegenContext)
+    private val serviceName = codegenContext.serviceShape.id.name.toPascalCase()
 
     private val codegenScope = arrayOf(
         "AsyncTrait" to ServerCargoDependency.AsyncTrait.toType(),
@@ -277,7 +279,7 @@ class ServerHttpBoundProtocolTraitImplGenerator(
                 }
             }
 
-            impl<B> #{SmithyHttpServer}::request::FromRequest<#{Marker}, B> for #{I}
+            impl<B> #{SmithyHttpServer}::request::FromRequest<crate::$serviceName, crate::operation_shape::$operationName, B> for #{I}
             where
                 B: #{SmithyHttpServer}::body::HttpBody + Send,
                 B: 'static,
@@ -309,7 +311,6 @@ class ServerHttpBoundProtocolTraitImplGenerator(
             """,
             *codegenScope,
             "I" to inputSymbol,
-            "Marker" to protocol.markerStruct(),
             "parse_request" to serverParseRequest(operationShape),
             "verifyAcceptHeader" to verifyAcceptHeader,
             "verifyAcceptHeaderStaticContentTypeInit" to verifyAcceptHeaderStaticContentTypeInit,
@@ -323,13 +324,13 @@ class ServerHttpBoundProtocolTraitImplGenerator(
         // to let them know.
         rustTemplate(
             """
-            impl #{SmithyHttpServer}::response::IntoResponse<#{Marker}> for #{O} {
+            impl #{SmithyHttpServer}::response::IntoResponse<crate::$serviceName, crate::operation_shape::$operationName> for #{O} {
                 fn into_response(self) -> #{SmithyHttpServer}::response::Response {
                     match #{serialize_response}(self) {
                         Ok(response) => response,
                         Err(e) => {
                             #{Tracing}::error!(error = %e, "failed to serialize response");
-                            #{SmithyHttpServer}::response::IntoResponse::<#{Marker}>::into_response(#{RuntimeError}::from(e))
+                            #{SmithyHttpServer}::response::IntoResponse::<crate::$serviceName, crate::operation_shape::$operationName>::into_response(#{RuntimeError}::from(e))
                         }
                     }
                 }
@@ -337,14 +338,13 @@ class ServerHttpBoundProtocolTraitImplGenerator(
             """,
             *codegenScope,
             "O" to outputSymbol,
-            "Marker" to protocol.markerStruct(),
             "serialize_response" to serverSerializeResponse(operationShape),
         )
 
         if (operationShape.operationErrors(model).isNotEmpty()) {
             rustTemplate(
                 """
-                impl #{SmithyHttpServer}::response::IntoResponse<#{Marker}> for #{E} {
+                impl #{SmithyHttpServer}::response::IntoResponse<crate::$serviceName, crate::operation_shape::$operationName> for #{E} {
                     fn into_response(self) -> #{SmithyHttpServer}::response::Response {
                         match #{serialize_error}(&self) {
                             Ok(mut response) => {
@@ -353,7 +353,7 @@ class ServerHttpBoundProtocolTraitImplGenerator(
                             },
                             Err(e) => {
                                 #{Tracing}::error!(error = %e, "failed to serialize response");
-                                #{SmithyHttpServer}::response::IntoResponse::<#{Marker}>::into_response(#{RuntimeError}::from(e))
+                                #{SmithyHttpServer}::response::IntoResponse::<crate::$serviceName, crate::operation_shape::$operationName>::into_response(#{RuntimeError}::from(e))
                             }
                         }
                     }
@@ -361,7 +361,6 @@ class ServerHttpBoundProtocolTraitImplGenerator(
                 """.trimIndent(),
                 *codegenScope,
                 "E" to errorSymbol,
-                "Marker" to protocol.markerStruct(),
                 "serialize_error" to serverSerializeError(operationShape),
             )
         }
diff --git a/rust-runtime/aws-smithy-http-server-python/src/error.rs b/rust-runtime/aws-smithy-http-server-python/src/error.rs
index 2cc308fea5..01c4984e1a 100644
--- a/rust-runtime/aws-smithy-http-server-python/src/error.rs
+++ b/rust-runtime/aws-smithy-http-server-python/src/error.rs
@@ -10,7 +10,7 @@ use aws_smithy_http_server::{
     protocol::{
         aws_json_10::AwsJson1_0, aws_json_11::AwsJson1_1, rest_json_1::RestJson1, rest_xml::RestXml,
     },
-    response::IntoResponse,
+    response::IntoResponseUniform,
 };
 use aws_smithy_types::date_time::{ConversionError, DateTimeParseError};
 use pyo3::{create_exception, exceptions::PyException as BasePyException, prelude::*, PyErr};
@@ -79,7 +79,7 @@ impl From<PyErr> for PyMiddlewareException {
     }
 }
 
-impl IntoResponse<RestJson1> for PyMiddlewareException {
+impl IntoResponseUniform<RestJson1> for PyMiddlewareException {
     fn into_response(self) -> http::Response<BoxBody> {
         http::Response::builder()
             .status(self.status_code)
@@ -90,7 +90,7 @@ impl IntoResponse<RestJson1> for PyMiddlewareException {
     }
 }
 
-impl IntoResponse<RestXml> for PyMiddlewareException {
+impl IntoResponseUniform<RestXml> for PyMiddlewareException {
     fn into_response(self) -> http::Response<BoxBody> {
         http::Response::builder()
             .status(self.status_code)
@@ -100,7 +100,7 @@ impl IntoResponse<RestXml> for PyMiddlewareException {
     }
 }
 
-impl IntoResponse<AwsJson1_0> for PyMiddlewareException {
+impl IntoResponseUniform<AwsJson1_0> for PyMiddlewareException {
     fn into_response(self) -> http::Response<BoxBody> {
         http::Response::builder()
             .status(self.status_code)
@@ -111,7 +111,7 @@ impl IntoResponse<AwsJson1_0> for PyMiddlewareException {
     }
 }
 
-impl IntoResponse<AwsJson1_1> for PyMiddlewareException {
+impl IntoResponseUniform<AwsJson1_1> for PyMiddlewareException {
     fn into_response(self) -> http::Response<BoxBody> {
         http::Response::builder()
             .status(self.status_code)
diff --git a/rust-runtime/aws-smithy-http-server-python/src/middleware/layer.rs b/rust-runtime/aws-smithy-http-server-python/src/middleware/layer.rs
index a658e1bb06..7cabcfaf49 100644
--- a/rust-runtime/aws-smithy-http-server-python/src/middleware/layer.rs
+++ b/rust-runtime/aws-smithy-http-server-python/src/middleware/layer.rs
@@ -14,7 +14,7 @@ use std::{
 
 use aws_smithy_http_server::{
     body::{Body, BoxBody},
-    response::IntoResponse,
+    response::IntoResponseUniform,
 };
 use futures::{future::BoxFuture, TryFutureExt};
 use http::{Request, Response};
@@ -47,7 +47,7 @@ impl<P> PyMiddlewareLayer<P> {
 
 impl<S, P> Layer<S> for PyMiddlewareLayer<P>
 where
-    PyMiddlewareException: IntoResponse<P>,
+    PyMiddlewareException: IntoResponseUniform<P>,
 {
     type Service = PyMiddlewareService<S>;
 
diff --git a/rust-runtime/aws-smithy-http-server/src/extension.rs b/rust-runtime/aws-smithy-http-server/src/extension.rs
index 17ff01e961..7695c2a1d2 100644
--- a/rust-runtime/aws-smithy-http-server/src/extension.rs
+++ b/rust-runtime/aws-smithy-http-server/src/extension.rs
@@ -216,10 +216,6 @@ mod tests {
                 "com.amazonaws.ebs",
                 "CompleteSnapshot",
             );
-
-            type Input = ();
-            type Output = ();
-            type Error = ();
         }
 
         // Apply `Plugin`.
diff --git a/rust-runtime/aws-smithy-http-server/src/operation/handler.rs b/rust-runtime/aws-smithy-http-server/src/operation/handler.rs
index 28ad3fd743..169950cfc0 100644
--- a/rust-runtime/aws-smithy-http-server/src/operation/handler.rs
+++ b/rust-runtime/aws-smithy-http-server/src/operation/handler.rs
@@ -6,148 +6,75 @@
 use std::{
     convert::Infallible,
     future::Future,
-    marker::PhantomData,
     task::{Context, Poll},
 };
 
 use futures_util::{future::Map, FutureExt};
 use tower::Service;
 
-use super::OperationShape;
-
 /// A utility trait used to provide an even interface for all operation handlers.
 ///
 /// See [`operation`](crate::operation) documentation for more info.
-pub trait Handler<Op, Exts>
-where
-    Op: OperationShape,
-{
-    type Future: Future<Output = Result<Op::Output, Op::Error>>;
-
-    fn call(&mut self, input: Op::Input, exts: Exts) -> Self::Future;
-}
-
-/// A utility trait used to provide an even interface over return types `Result<Ok, Error>`/`Ok`.
-trait IntoResult<Ok, Error> {
-    fn into_result(self) -> Result<Ok, Error>;
-}
-
-// We can convert from `Result<Ok, Error>` to `Result<Ok, Error>`.
-impl<Ok, Error> IntoResult<Ok, Error> for Result<Ok, Error> {
-    fn into_result(self) -> Result<Ok, Error> {
-        self
-    }
-}
+pub trait Handler<Input>: Clone + Send + 'static {
+    type Future: Future;
 
-// We can convert from `T` to `Result<T, Infallible>`.
-impl<Ok> IntoResult<Ok, Infallible> for Ok {
-    fn into_result(self) -> Result<Ok, Infallible> {
-        Ok(self)
-    }
+    fn call(self, request: Input) -> Self::Future;
 }
 
-// fn(Input) -> Output
-impl<Op, F, Fut> Handler<Op, ()> for F
-where
-    Op: OperationShape,
-    F: Fn(Op::Input) -> Fut,
-    Fut: Future,
-    Fut::Output: IntoResult<Op::Output, Op::Error>,
-{
-    type Future = Map<Fut, fn(Fut::Output) -> Result<Op::Output, Op::Error>>;
-
-    fn call(&mut self, input: Op::Input, _exts: ()) -> Self::Future {
-        (self)(input).map(IntoResult::into_result)
-    }
-}
-
-// fn(Input, Ext_i) -> Output
 macro_rules! impl_handler {
-    ($($var:ident),+) => (
-        impl<Op, F, Fut, $($var,)*> Handler<Op, ($($var,)*)> for F
+    ($($ty: ident),*) => {
+        impl<$($ty,)* F, Fut> Handler<($($ty,)*)> for F
         where
-            Op: OperationShape,
-            F: Fn(Op::Input, $($var,)*) -> Fut,
+            F: Fn($($ty),*) -> Fut,
+            F: Clone + Send + 'static,
             Fut: Future,
-            Fut::Output: IntoResult<Op::Output, Op::Error>,
         {
-            type Future = Map<Fut, fn(Fut::Output) -> Result<Op::Output, Op::Error>>;
+            type Future = Fut;
 
-            fn call(&mut self, input: Op::Input, exts: ($($var,)*)) -> Self::Future {
-                #[allow(non_snake_case)]
-                let ($($var,)*) = exts;
-                (self)(input, $($var,)*).map(IntoResult::into_result)
+            #[allow(non_snake_case)]
+            fn call(self, ($($ty,)*): ($($ty,)*)) -> Self::Future {
+                self($($ty),*)
             }
         }
-    )
-}
-
-impl_handler!(Exts0);
-impl_handler!(Exts0, Exts1);
-impl_handler!(Exts0, Exts1, Exts2);
-impl_handler!(Exts0, Exts1, Exts2, Exts3);
-impl_handler!(Exts0, Exts1, Exts2, Exts3, Exts4);
-impl_handler!(Exts0, Exts1, Exts2, Exts3, Exts4, Exts5);
-impl_handler!(Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6);
-impl_handler!(Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7);
-impl_handler!(Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7, Exts8);
-
-/// An extension trait for [`Handler`].
-pub trait HandlerExt<Op, Exts>: Handler<Op, Exts>
-where
-    Op: OperationShape,
-{
-    /// Convert the [`Handler`] into a [`Service`].
-    fn into_service(self) -> IntoService<Op, Self>
-    where
-        Self: Sized,
-    {
-        IntoService {
-            handler: self,
-            _operation: PhantomData,
-        }
-    }
+    };
 }
 
-impl<Op, Exts, H> HandlerExt<Op, Exts> for H
-where
-    Op: OperationShape,
-    H: Handler<Op, Exts>,
-{
-}
+impl_handler!(T0);
+impl_handler!(T0, T2);
+impl_handler!(T0, T2, T3);
+impl_handler!(T0, T2, T3, T4);
+impl_handler!(T0, T2, T3, T4, T5);
+impl_handler!(T0, T2, T3, T4, T5, T6);
+impl_handler!(T0, T2, T3, T4, T5, T6, T7);
+impl_handler!(T0, T2, T3, T4, T5, T6, T7, T8);
+impl_handler!(T0, T2, T3, T4, T5, T6, T7, T8, T9);
 
 /// A [`Service`] provided for every [`Handler`].
-pub struct IntoService<Op, H> {
-    pub(crate) handler: H,
-    pub(crate) _operation: PhantomData<Op>,
+#[derive(Debug, Clone)]
+pub struct IntoService<H> {
+    handler: H,
 }
 
-impl<Op, H> Clone for IntoService<Op, H>
+impl<Input, H> Service<Input> for IntoService<H>
 where
-    H: Clone,
+    H: Handler<Input>,
+    H::Future: Future,
 {
-    fn clone(&self) -> Self {
-        Self {
-            handler: self.handler.clone(),
-            _operation: PhantomData,
-        }
-    }
-}
-
-impl<Op, Exts, H> Service<(Op::Input, Exts)> for IntoService<Op, H>
-where
-    Op: OperationShape,
-    H: Handler<Op, Exts>,
-{
-    type Response = Op::Output;
-    type Error = Op::Error;
-    type Future = H::Future;
+    type Response = <H::Future as Future>::Output;
+    type Error = Infallible;
+    type Future = Map<H::Future, fn(Self::Response) -> Result<Self::Response, Infallible>>;
 
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, (input, exts): (Op::Input, Exts)) -> Self::Future {
-        self.handler.call(input, exts)
+    fn call(&mut self, request: Input) -> Self::Future {
+        self.handler.clone().call(request).map(Ok)
+    }
+}
+
+impl<H> IntoService<H> {
+    pub fn new(handler: H) -> Self {
+        Self { handler }
     }
 }
diff --git a/rust-runtime/aws-smithy-http-server/src/operation/mod.rs b/rust-runtime/aws-smithy-http-server/src/operation/mod.rs
index 8450da8366..5873648686 100644
--- a/rust-runtime/aws-smithy-http-server/src/operation/mod.rs
+++ b/rust-runtime/aws-smithy-http-server/src/operation/mod.rs
@@ -33,10 +33,6 @@
 //!
 //! impl OperationShape for GetShopping {
 //!     const ID: ShapeId = ShapeId::new("namespace#GetShopping", "namespace", "GetShopping");
-//!
-//!     type Input = CartIdentifier;
-//!     type Output = ShoppingCart;
-//!     type Error = GetShoppingError;
 //! }
 //! ```
 //!
@@ -110,10 +106,6 @@
 //! # pub struct GetShopping;
 //! # impl OperationShape for GetShopping {
 //! #    const ID: ShapeId = ShapeId::new("namespace#GetShopping", "namespace", "GetShopping");
-//! #
-//! #    type Input = CartIdentifier;
-//! #    type Output = ShoppingCart;
-//! #    type Error = GetShoppingError;
 //! # }
 //! # type OpFuture = std::future::Ready<Result<ShoppingCart, GetShoppingError>>;
 //! // Construction of an `Operation` from a `Handler`.
@@ -122,8 +114,6 @@
 //!     todo!()
 //! }
 //!
-//! let operation = GetShopping::from_handler(op_handler);
-//!
 //! // Construction of an `Operation` from a `Service`.
 //!
 //! pub struct OpService;
@@ -142,8 +132,6 @@
 //!     }
 //! }
 //!
-//! let operation = GetShopping::from_service(OpService);
-//!
 //! ```
 //!
 //! ## Upgrading Smithy services to HTTP services
@@ -161,11 +149,70 @@
 //! [Smithy operation]: https://awslabs.github.io/smithy/2.0/spec/service-types.html#operation
 
 mod handler;
-mod operation_service;
 mod shape;
 mod upgrade;
 
+use std::{
+    marker::PhantomData,
+    task::{Context, Poll},
+};
+
 pub use handler::*;
-pub use operation_service::*;
 pub use shape::*;
+use tower::Service;
 pub use upgrade::*;
+
+pub trait FixedService: Service<Self::FixedInput> {
+    type FixedInput;
+}
+
+#[derive(Debug)]
+pub struct FixInput<Input, S> {
+    inner: S,
+    _input: PhantomData<Input>,
+}
+
+impl<Input, S> Clone for FixInput<Input, S>
+where
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            _input: PhantomData,
+        }
+    }
+}
+
+impl<Input, S> FixInput<Input, S> {
+    pub fn new(inner: S) -> Self {
+        Self {
+            inner,
+            _input: PhantomData,
+        }
+    }
+}
+
+impl<Input, S> Service<Input> for FixInput<Input, S>
+where
+    S: Service<Input>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Input) -> Self::Future {
+        self.inner.call(req)
+    }
+}
+
+impl<Input, S> FixedService for FixInput<Input, S>
+where
+    S: Service<Input>,
+{
+    type FixedInput = Input;
+}
diff --git a/rust-runtime/aws-smithy-http-server/src/operation/operation_service.rs b/rust-runtime/aws-smithy-http-server/src/operation/operation_service.rs
deleted file mode 100644
index b9a87aa6e9..0000000000
--- a/rust-runtime/aws-smithy-http-server/src/operation/operation_service.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-use std::{
-    marker::PhantomData,
-    task::{Context, Poll},
-};
-
-use tower::Service;
-
-use super::OperationShape;
-
-/// A utility trait used to provide an even interface for all operation services.
-///
-/// This serves to take [`Service`]s of the form `Service<(Op::Input, Ext0, Ext1, ...)>` to the canonical
-/// representation of `Service<(Input, (Ext0, Ext1, ...))>` inline with
-/// [`IntoService`](super::IntoService).
-///
-/// See [`operation`](crate::operation) documentation for more info.
-pub trait OperationService<Op, Exts>: Service<Self::Normalized, Response = Op::Output, Error = Op::Error>
-where
-    Op: OperationShape,
-{
-    type Normalized;
-
-    // Normalize the request type.
-    fn normalize(input: Op::Input, exts: Exts) -> Self::Normalized;
-}
-
-// `Service<Op::Input>`
-impl<Op, S> OperationService<Op, ()> for S
-where
-    Op: OperationShape,
-    S: Service<Op::Input, Response = Op::Output, Error = Op::Error>,
-{
-    type Normalized = Op::Input;
-
-    fn normalize(input: Op::Input, _exts: ()) -> Self::Normalized {
-        input
-    }
-}
-
-// `Service<(Op::Input, Ext0)>`
-impl<Op, Ext0, S> OperationService<Op, (Ext0,)> for S
-where
-    Op: OperationShape,
-    S: Service<(Op::Input, Ext0), Response = Op::Output, Error = Op::Error>,
-{
-    type Normalized = (Op::Input, Ext0);
-
-    fn normalize(input: Op::Input, exts: (Ext0,)) -> Self::Normalized {
-        (input, exts.0)
-    }
-}
-
-// `Service<(Op::Input, Ext0, Ext1)>`
-impl<Op, Ext0, Ext1, S> OperationService<Op, (Ext0, Ext1)> for S
-where
-    Op: OperationShape,
-    S: Service<(Op::Input, Ext0, Ext1), Response = Op::Output, Error = Op::Error>,
-{
-    type Normalized = (Op::Input, Ext0, Ext1);
-
-    fn normalize(input: Op::Input, exts: (Ext0, Ext1)) -> Self::Normalized {
-        (input, exts.0, exts.1)
-    }
-}
-
-/// An extension trait of [`OperationService`].
-pub trait OperationServiceExt<Op, Exts>: OperationService<Op, Exts>
-where
-    Op: OperationShape,
-{
-    /// Convert the [`OperationService`] into a canonicalized [`Service`].
-    fn normalize(self) -> Normalize<Op, Self>
-    where
-        Self: Sized,
-    {
-        Normalize {
-            inner: self,
-            _operation: PhantomData,
-        }
-    }
-}
-
-impl<F, Op, Exts> OperationServiceExt<Op, Exts> for F
-where
-    Op: OperationShape,
-    F: OperationService<Op, Exts>,
-{
-}
-
-/// A [`Service`] normalizing the request type of a [`OperationService`].
-#[derive(Debug)]
-pub struct Normalize<Op, S> {
-    pub(crate) inner: S,
-    pub(crate) _operation: PhantomData<Op>,
-}
-
-impl<Op, S> Clone for Normalize<Op, S>
-where
-    S: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-            _operation: PhantomData,
-        }
-    }
-}
-
-impl<Op, S, Exts> Service<(Op::Input, Exts)> for Normalize<Op, S>
-where
-    Op: OperationShape,
-    S: OperationService<Op, Exts>,
-{
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = <S as Service<S::Normalized>>::Future;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    fn call(&mut self, (input, exts): (Op::Input, Exts)) -> Self::Future {
-        let req = S::normalize(input, exts);
-        self.inner.call(req)
-    }
-}
diff --git a/rust-runtime/aws-smithy-http-server/src/operation/shape.rs b/rust-runtime/aws-smithy-http-server/src/operation/shape.rs
index 6d3d774868..4d926eb987 100644
--- a/rust-runtime/aws-smithy-http-server/src/operation/shape.rs
+++ b/rust-runtime/aws-smithy-http-server/src/operation/shape.rs
@@ -3,9 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use std::marker::PhantomData;
-
-use super::{Handler, IntoService, Normalize, OperationService};
 use crate::shape_id::ShapeId;
 
 /// Models the [Smithy Operation shape].
@@ -14,42 +11,4 @@ use crate::shape_id::ShapeId;
 pub trait OperationShape {
     /// The ID of the operation.
     const ID: ShapeId;
-
-    /// The operation input.
-    type Input;
-    /// The operation output.
-    type Output;
-    /// The operation error. [`Infallible`](std::convert::Infallible) in the case where no error
-    /// exists.
-    type Error;
-}
-
-/// An extension trait over [`OperationShape`].
-pub trait OperationShapeExt: OperationShape {
-    /// Creates a new [`Service`](tower::Service), [`IntoService`], for well-formed [`Handler`]s.
-    fn from_handler<H, Exts>(handler: H) -> IntoService<Self, H>
-    where
-        H: Handler<Self, Exts>,
-        Self: Sized,
-    {
-        IntoService {
-            handler,
-            _operation: PhantomData,
-        }
-    }
-
-    /// Creates a new normalized [`Service`](tower::Service), [`Normalize`], for well-formed
-    /// [`Service`](tower::Service)s.
-    fn from_service<S, Exts>(svc: S) -> Normalize<Self, S>
-    where
-        S: OperationService<Self, Exts>,
-        Self: Sized,
-    {
-        Normalize {
-            inner: svc,
-            _operation: PhantomData,
-        }
-    }
 }
-
-impl<S> OperationShapeExt for S where S: OperationShape {}
diff --git a/rust-runtime/aws-smithy-http-server/src/operation/upgrade.rs b/rust-runtime/aws-smithy-http-server/src/operation/upgrade.rs
index 15e87ebc19..7cd458389f 100644
--- a/rust-runtime/aws-smithy-http-server/src/operation/upgrade.rs
+++ b/rust-runtime/aws-smithy-http-server/src/operation/upgrade.rs
@@ -21,43 +21,33 @@ use crate::{
     runtime_error::InternalFailureException, service::ServiceShape,
 };
 
-use super::OperationShape;
+use super::{FixedService, OperationShape};
 
 /// A [`Plugin`] responsible for taking an operation [`Service`], accepting and returning Smithy
 /// types and converting it into a [`Service`] taking and returning [`http`] types.
 ///
 /// See [`Upgrade`].
-#[derive(Debug, Clone)]
-pub struct UpgradePlugin<Extractors> {
-    _extractors: PhantomData<Extractors>,
-}
-
-impl<Extractors> Default for UpgradePlugin<Extractors> {
-    fn default() -> Self {
-        Self {
-            _extractors: PhantomData,
-        }
-    }
-}
+#[derive(Debug, Default, Clone)]
+pub struct UpgradePlugin;
 
-impl<Extractors> UpgradePlugin<Extractors> {
+impl UpgradePlugin {
     /// Creates a new [`UpgradePlugin`].
     pub fn new() -> Self {
         Self::default()
     }
 }
 
-impl<Ser, Op, T, Extractors> Plugin<Ser, Op, T> for UpgradePlugin<Extractors>
+impl<Ser, Op, T> Plugin<Ser, Op, T> for UpgradePlugin
 where
     Ser: ServiceShape,
     Op: OperationShape,
 {
-    type Output = Upgrade<Ser::Protocol, (Op::Input, Extractors), T>;
+    type Output = Upgrade<Ser, Op, T>;
 
     fn apply(&self, inner: T) -> Self::Output {
         Upgrade {
-            _protocol: PhantomData,
-            _input: PhantomData,
+            _service: PhantomData,
+            _operation: PhantomData,
             inner,
         }
     }
@@ -65,20 +55,20 @@ where
 
 /// A [`Service`] responsible for wrapping an operation [`Service`] accepting and returning Smithy
 /// types, and converting it into a [`Service`] accepting and returning [`http`] types.
-pub struct Upgrade<Protocol, Input, S> {
-    _protocol: PhantomData<Protocol>,
-    _input: PhantomData<Input>,
+pub struct Upgrade<Ser, Op, S> {
+    _service: PhantomData<Ser>,
+    _operation: PhantomData<Op>,
     inner: S,
 }
 
-impl<P, Input, S> Clone for Upgrade<P, Input, S>
+impl<Ser, Op, S> Clone for Upgrade<Ser, Op, S>
 where
     S: Clone,
 {
     fn clone(&self) -> Self {
         Self {
-            _protocol: PhantomData,
-            _input: PhantomData,
+            _service: PhantomData,
+            _operation: PhantomData,
             inner: self.inner.clone(),
         }
     }
@@ -99,27 +89,27 @@ pin_project! {
     }
 }
 
-type InnerAlias<Input, Protocol, B, S> = Inner<<Input as FromRequest<Protocol, B>>::Future, Oneshot<S, Input>>;
+type InnerAlias<Input, Ser, Op, B, S> = Inner<<Input as FromRequest<Ser, Op, B>>::Future, Oneshot<S, Input>>;
 
 pin_project! {
     /// The [`Service::Future`] of [`Upgrade`].
-    pub struct UpgradeFuture<Protocol, Input, B, S>
+    pub struct UpgradeFuture<Ser, Op, B, S>
     where
-        Input: FromRequest<Protocol, B>,
-        S: Service<Input>,
+        S: FixedService,
+        S::FixedInput: FromRequest<Ser, Op, B>,
     {
         service: Option<S>,
         #[pin]
-        inner: InnerAlias<Input, Protocol, B, S>
+        inner: InnerAlias<S::FixedInput, Ser, Op, B, S>
     }
 }
 
-impl<P, Input, B, S> Future for UpgradeFuture<P, Input, B, S>
+impl<Ser, Op, B, S> Future for UpgradeFuture<Ser, Op, B, S>
 where
-    Input: FromRequest<P, B>,
-    S: Service<Input>,
-    S::Response: IntoResponse<P>,
-    S::Error: IntoResponse<P>,
+    S: FixedService,
+    S::FixedInput: FromRequest<Ser, Op, B>,
+    S::Response: IntoResponse<Ser, Op>,
+    S::Error: IntoResponse<Ser, Op>,
 {
     type Output = Result<http::Response<crate::body::BoxBody>, Infallible>;
 
@@ -155,16 +145,16 @@ where
     }
 }
 
-impl<P, Input, B, S> Service<http::Request<B>> for Upgrade<P, Input, S>
+impl<Ser, Op, B, S> Service<http::Request<B>> for Upgrade<Ser, Op, S>
 where
-    Input: FromRequest<P, B>,
-    S: Service<Input> + Clone,
-    S::Response: IntoResponse<P>,
-    S::Error: IntoResponse<P>,
+    S: FixedService + Clone,
+    S::FixedInput: FromRequest<Ser, Op, B>,
+    S::Response: IntoResponse<Ser, Op>,
+    S::Error: IntoResponse<Ser, Op>,
 {
     type Response = http::Response<crate::body::BoxBody>;
     type Error = Infallible;
-    type Future = UpgradeFuture<P, Input, B, S>;
+    type Future = UpgradeFuture<Ser, Op, B, S>;
 
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
@@ -176,7 +166,7 @@ where
         UpgradeFuture {
             service: Some(service),
             inner: Inner::FromRequest {
-                inner: <Input as FromRequest<P, B>>::from_request(req),
+                inner: <S::FixedInput as FromRequest<Ser, Op, B>>::from_request(req),
             },
         }
     }
@@ -184,25 +174,25 @@ where
 
 /// A [`Service`] which always returns an internal failure message and logs an error.
 #[derive(Copy)]
-pub struct MissingFailure<P> {
-    _protocol: PhantomData<fn(P)>,
+pub struct MissingFailure<Ser, Op> {
+    _protocol: PhantomData<fn((Ser, Op))>,
 }
 
-impl<P> Default for MissingFailure<P> {
+impl<Ser, Op> Default for MissingFailure<Ser, Op> {
     fn default() -> Self {
         Self { _protocol: PhantomData }
     }
 }
 
-impl<P> Clone for MissingFailure<P> {
+impl<Ser, Op> Clone for MissingFailure<Ser, Op> {
     fn clone(&self) -> Self {
         MissingFailure { _protocol: PhantomData }
     }
 }
 
-impl<R, P> Service<R> for MissingFailure<P>
+impl<R, Ser, Op> Service<R> for MissingFailure<Ser, Op>
 where
-    InternalFailureException: IntoResponse<P>,
+    InternalFailureException: IntoResponse<Ser, Op>,
 {
     type Response = http::Response<BoxBody>;
     type Error = Infallible;
diff --git a/rust-runtime/aws-smithy-http-server/src/plugin/closure.rs b/rust-runtime/aws-smithy-http-server/src/plugin/closure.rs
index d78ba4c937..e217703610 100644
--- a/rust-runtime/aws-smithy-http-server/src/plugin/closure.rs
+++ b/rust-runtime/aws-smithy-http-server/src/plugin/closure.rs
@@ -41,8 +41,8 @@ where
 /// #   type Protocol = ();
 /// #   type Operations = Operation;
 /// # }
-/// # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); type Input = (); type Output = (); type Error = (); }
-/// # impl OperationShape for GetPokemonSpecies { const ID: ShapeId = ShapeId::new("", "", ""); type Input = (); type Output = (); type Error = (); }
+/// # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); }
+/// # impl OperationShape for GetPokemonSpecies { const ID: ShapeId = ShapeId::new("", "", ""); }
 /// # impl ContainsOperation<CheckHealth> for PokemonService { const VALUE: Operation = Operation::CheckHealth; }
 /// # impl ContainsOperation<GetPokemonSpecies> for PokemonService { const VALUE: Operation = Operation::GetPokemonSpecies; }
 /// use aws_smithy_http_server::plugin::plugin_from_operation_fn;
diff --git a/rust-runtime/aws-smithy-http-server/src/plugin/filter.rs b/rust-runtime/aws-smithy-http-server/src/plugin/filter.rs
index f29fac8e50..79932b1194 100644
--- a/rust-runtime/aws-smithy-http-server/src/plugin/filter.rs
+++ b/rust-runtime/aws-smithy-http-server/src/plugin/filter.rs
@@ -62,7 +62,7 @@ impl<Inner, F> ModelMarker for FilterByOperation<Inner, F> where Inner: ModelMar
 /// # impl ServiceShape for PokemonService { const VERSION: Option<&'static str> = None; const ID: ShapeId = ShapeId::new("", "", ""); type Operations = Operation; type Protocol = (); }
 /// # impl ContainsOperation<CheckHealth> for PokemonService { const VALUE: Operation = Operation::CheckHealth; }
 /// # struct CheckHealth;
-/// # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); type Input = (); type Output = (); type Error = (); }
+/// # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); }
 /// # impl Plugin<PokemonService, CheckHealth, ()> for Pl { type Output = (); fn apply(&self, input: ()) -> Self::Output { input }}
 /// # let plugin = Pl;
 /// # let svc = ();
diff --git a/rust-runtime/aws-smithy-http-server/src/plugin/mod.rs b/rust-runtime/aws-smithy-http-server/src/plugin/mod.rs
index 5bbeda3eba..7340863a5b 100644
--- a/rust-runtime/aws-smithy-http-server/src/plugin/mod.rs
+++ b/rust-runtime/aws-smithy-http-server/src/plugin/mod.rs
@@ -79,8 +79,8 @@
 //! #   type Protocol = ();
 //! #   type Operations = Operation;
 //! # }
-//! # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); type Input = (); type Output = (); type Error = (); }
-//! # impl OperationShape for GetPokemonSpecies { const ID: ShapeId = ShapeId::new("", "", ""); type Input = (); type Output = (); type Error = (); }
+//! # impl OperationShape for CheckHealth { const ID: ShapeId = ShapeId::new("", "", ""); }
+//! # impl OperationShape for GetPokemonSpecies { const ID: ShapeId = ShapeId::new("", "", ""); }
 //! # impl ContainsOperation<CheckHealth> for PokemonService { const VALUE: Operation = Operation::CheckHealth; }
 //! # impl ContainsOperation<GetPokemonSpecies> for PokemonService { const VALUE: Operation = Operation::GetPokemonSpecies; }
 //! use aws_smithy_http_server::plugin::plugin_from_operation_fn;
@@ -293,9 +293,6 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 /// #         "com.amazonaws.simple",
 /// #         "CheckHealth",
 /// #     );
-/// #     type Input = CheckHealthInput;
-/// #     type Output = CheckHealthOutput;
-/// #     type Error = std::convert::Infallible;
 /// # }
 ///
 /// /// A model plugin that can only be applied to the `CheckHealth` operation.
@@ -328,9 +325,9 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 ///     _exts: PhantomData<Exts>,
 /// }
 ///
-/// impl<S, Exts> Service<(<CheckHealth as OperationShape>::Input, Exts)> for CheckHealthService<S, Exts>
+/// impl<S, Exts> Service<(CheckHealthInput, Exts)> for CheckHealthService<S, Exts>
 /// where
-///     S: Service<(<CheckHealth as OperationShape>::Input, Exts)>,
+///     S: Service<(CheckHealthInput, Exts)>,
 /// {
 ///     type Response = S::Response;
 ///     type Error = S::Error;
@@ -340,7 +337,7 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 ///         self.inner.poll_ready(cx)
 ///     }
 ///
-///     fn call(&mut self, req: (<CheckHealth as OperationShape>::Input, Exts)) -> Self::Future {
+///     fn call(&mut self, req: (CheckHealthInput, Exts)) -> Self::Future {
 ///         let (input, _exts) = &req;
 ///
 ///         // We have access to `CheckHealth`'s modeled operation input!
@@ -394,9 +391,6 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 /// #         "com.amazonaws.simple",
 /// #         "CheckHealth",
 /// #     );
-/// #     type Input = CheckHealthInput;
-/// #     type Output = CheckHealthOutput;
-/// #     type Error = std::convert::Infallible;
 /// # }
 ///
 /// #[derive(Clone)]
@@ -405,9 +399,9 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 ///     _exts: PhantomData<Exts>,
 /// }
 ///
-/// impl<S, Exts> Service<(<CheckHealth as OperationShape>::Input, Exts)> for CheckHealthService<S, Exts>
+/// impl<S, Exts> Service<(CheckHealthInput, Exts)> for CheckHealthService<S, Exts>
 /// where
-///     S: Service<(<CheckHealth as OperationShape>::Input, Exts)>,
+///     S: Service<(CheckHealthInput, Exts)>,
 /// {
 ///     type Response = S::Response;
 ///     type Error = S::Error;
@@ -417,7 +411,7 @@ impl<'a, Pl> HttpMarker for &'a Pl where Pl: HttpMarker {}
 ///         self.inner.poll_ready(cx)
 ///     }
 ///
-///     fn call(&mut self, req: (<CheckHealth as OperationShape>::Input, Exts)) -> Self::Future {
+///     fn call(&mut self, req: (CheckHealthInput, Exts)) -> Self::Future {
 ///         let (input, _exts) = &req;
 ///
 ///         // We have access to `CheckHealth`'s modeled operation input!
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/router.rs
index 2cd48f8e61..0f3e0f7240 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/router.rs
@@ -3,14 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use std::convert::Infallible;
-
-use tower::Layer;
 use tower::Service;
 
-use crate::body::BoxBody;
 use crate::routing::tiny_map::TinyMap;
-use crate::routing::Route;
 use crate::routing::Router;
 
 use http::header::ToStrError;
@@ -50,37 +45,9 @@ pub struct AwsJsonRouter<S> {
     routes: TinyMap<String, S, ROUTE_CUTOFF>,
 }
 
-impl<S> AwsJsonRouter<S> {
-    /// Applies a [`Layer`] uniformly to all routes.
-    pub fn layer<L>(self, layer: L) -> AwsJsonRouter<L::Service>
-    where
-        L: Layer<S>,
-    {
-        AwsJsonRouter {
-            routes: self
-                .routes
-                .into_iter()
-                .map(|(key, route)| (key, layer.layer(route)))
-                .collect(),
-        }
-    }
-
-    /// Applies type erasure to the inner route using [`Route::new`].
-    pub fn boxed<B>(self) -> AwsJsonRouter<Route<B>>
-    where
-        S: Service<http::Request<B>, Response = http::Response<BoxBody>, Error = Infallible>,
-        S: Send + Clone + 'static,
-        S::Future: Send + 'static,
-    {
-        AwsJsonRouter {
-            routes: self.routes.into_iter().map(|(key, s)| (key, Route::new(s))).collect(),
-        }
-    }
-}
-
 impl<B, S> Router<B> for AwsJsonRouter<S>
 where
-    S: Clone,
+    S: Service<http::Request<B>, Error = std::convert::Infallible> + Clone,
 {
     type Service = S;
     type Error = Error;
@@ -125,6 +92,7 @@ mod tests {
 
     use http::{HeaderMap, HeaderValue, Method};
     use pretty_assertions::assert_eq;
+    use tower::service_fn;
 
     #[tokio::test]
     async fn simple_routing() {
@@ -132,7 +100,12 @@ mod tests {
         let router: AwsJsonRouter<_> = routes
             .clone()
             .into_iter()
-            .map(|operation| (operation.to_string(), ()))
+            .map(|operation| {
+                (
+                    operation.to_string(),
+                    service_fn(move |_| async move { Ok(http::Request::new(operation)) }),
+                )
+            })
             .collect();
 
         let mut headers = HeaderMap::new();
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/runtime_error.rs b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/runtime_error.rs
index 8970d16f30..5ecfabf967 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/runtime_error.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json/runtime_error.rs
@@ -4,7 +4,7 @@
  */
 
 use crate::protocol::aws_json_11::AwsJson1_1;
-use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::runtime_error::{InternalFailureException, INVALID_HTTP_RESPONSE_FOR_RUNTIME_ERROR_PANIC_MESSAGE};
 use crate::{extension::RuntimeErrorExtension, protocol::aws_json_10::AwsJson1_0};
 use http::StatusCode;
@@ -42,19 +42,15 @@ impl RuntimeError {
     }
 }
 
-impl IntoResponse<AwsJson1_0> for InternalFailureException {
+impl IntoResponseUniform<AwsJson1_0> for InternalFailureException {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
-        IntoResponse::<AwsJson1_0>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
+        IntoResponseUniform::<AwsJson1_0>::into_response(RuntimeError::InternalFailure(
+            crate::Error::new(String::new()),
+        ))
     }
 }
 
-impl IntoResponse<AwsJson1_1> for InternalFailureException {
-    fn into_response(self) -> http::Response<crate::body::BoxBody> {
-        IntoResponse::<AwsJson1_1>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
-    }
-}
-
-impl IntoResponse<AwsJson1_0> for RuntimeError {
+impl IntoResponseUniform<AwsJson1_0> for RuntimeError {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
         let res = http::Response::builder()
             .status(self.status_code())
@@ -72,7 +68,7 @@ impl IntoResponse<AwsJson1_0> for RuntimeError {
     }
 }
 
-impl IntoResponse<AwsJson1_1> for RuntimeError {
+impl IntoResponseUniform<AwsJson1_1> for RuntimeError {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
         let res = http::Response::builder()
             .status(self.status_code())
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_10/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_10/router.rs
index f3093685e2..0a3491efe2 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_10/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_10/router.rs
@@ -5,14 +5,14 @@
 
 use crate::body::{empty, BoxBody};
 use crate::extension::RuntimeErrorExtension;
-use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::routing::{method_disallowed, UNKNOWN_OPERATION_EXCEPTION};
 
 use super::AwsJson1_0;
 
 pub use crate::protocol::aws_json::router::*;
 
-impl IntoResponse<AwsJson1_0> for Error {
+impl IntoResponseUniform<AwsJson1_0> for Error {
     fn into_response(self) -> http::Response<BoxBody> {
         match self {
             Error::MethodNotAllowed => method_disallowed(),
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_11/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_11/router.rs
index 898d8c29af..a34ed787f7 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_11/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/aws_json_11/router.rs
@@ -5,14 +5,14 @@
 
 use crate::body::{empty, BoxBody};
 use crate::extension::RuntimeErrorExtension;
-use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::routing::{method_disallowed, UNKNOWN_OPERATION_EXCEPTION};
 
 use super::AwsJson1_1;
 
 pub use crate::protocol::aws_json::router::*;
 
-impl IntoResponse<AwsJson1_1> for Error {
+impl IntoResponseUniform<AwsJson1_1> for Error {
     fn into_response(self) -> http::Response<BoxBody> {
         match self {
             Error::MethodNotAllowed => method_disallowed(),
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/rest/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/rest/router.rs
index fbbb98ee81..18cd4ed805 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/rest/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/rest/router.rs
@@ -3,14 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use std::convert::Infallible;
-
-use crate::body::BoxBody;
 use crate::routing::request_spec::Match;
 use crate::routing::request_spec::RequestSpec;
-use crate::routing::Route;
 use crate::routing::Router;
-use tower::Layer;
 use tower::Service;
 
 use thiserror::Error;
@@ -35,37 +30,9 @@ pub struct RestRouter<S> {
     routes: Vec<(RequestSpec, S)>,
 }
 
-impl<S> RestRouter<S> {
-    /// Applies a [`Layer`] uniformly to all routes.
-    pub fn layer<L>(self, layer: L) -> RestRouter<L::Service>
-    where
-        L: Layer<S>,
-    {
-        RestRouter {
-            routes: self
-                .routes
-                .into_iter()
-                .map(|(request_spec, route)| (request_spec, layer.layer(route)))
-                .collect(),
-        }
-    }
-
-    /// Applies type erasure to the inner route using [`Route::new`].
-    pub fn boxed<B>(self) -> RestRouter<Route<B>>
-    where
-        S: Service<http::Request<B>, Response = http::Response<BoxBody>, Error = Infallible>,
-        S: Send + Clone + 'static,
-        S::Future: Send + 'static,
-    {
-        RestRouter {
-            routes: self.routes.into_iter().map(|(spec, s)| (spec, Route::new(s))).collect(),
-        }
-    }
-}
-
 impl<B, S> Router<B> for RestRouter<S>
 where
-    S: Clone,
+    S: Service<http::Request<B>, Error = std::convert::Infallible> + Clone,
 {
     type Service = S;
     type Error = Error;
@@ -115,11 +82,12 @@ mod tests {
     use crate::{protocol::test_helpers::req, routing::request_spec::*};
 
     use http::Method;
+    use tower::service_fn;
 
     // This test is a rewrite of `mux.spec.ts`.
     // https://github.com/awslabs/smithy-typescript/blob/fbf97a9bf4c1d8cf7f285ea7c24e1f0ef280142a/smithy-typescript-ssdk-libs/server-common/src/httpbinding/mux.spec.ts
-    #[test]
-    fn simple_routing() {
+    #[tokio::test]
+    async fn simple_routing() {
         let request_specs: Vec<(RequestSpec, &'static str)> = vec![
             (
                 RequestSpec::from_parts(
@@ -169,7 +137,10 @@ mod tests {
         // Test both RestJson1 and RestXml routers.
         let router: RestRouter<_> = request_specs
             .into_iter()
-            .map(|(spec, svc_name)| (spec, svc_name))
+            .map(|(spec, svc_name)| {
+                let svc = service_fn(move |_| async move { Ok(http::Request::new(svc_name)) });
+                (spec, svc)
+            })
             .collect();
 
         let hits = vec![
@@ -186,7 +157,14 @@ mod tests {
             ("QueryKeyOnly", Method::POST, "/query_key_only?foo=&"),
         ];
         for (svc_name, method, uri) in &hits {
-            assert_eq!(router.match_route(&req(method, uri, None)).unwrap(), *svc_name);
+            let name = router
+                .match_route(&req(method, uri, None))
+                .unwrap()
+                .call(http::Request::new(()))
+                .await
+                .unwrap()
+                .into_body();
+            assert_eq!(name, *svc_name);
         }
 
         for (_, _, uri) in hits {
@@ -257,7 +235,10 @@ mod tests {
 
         let router: RestRouter<_> = request_specs
             .into_iter()
-            .map(|(spec, svc_name)| (spec, svc_name))
+            .map(|(spec, svc_name)| {
+                let svc = service_fn(move |_| async move { Ok(http::Request::new(svc_name)) });
+                (spec, svc)
+            })
             .collect();
 
         let hits = vec![
@@ -266,8 +247,15 @@ mod tests {
             ("B1", Method::GET, "/b/foo/bar/baz"),
             ("B2", Method::GET, "/b/foo?q=baz"),
         ];
-        for (svc_name, method, uri) in hits {
-            assert_eq!(router.match_route(&req(&method, uri, None)).unwrap(), svc_name);
+        for (svc_name, method, uri) in hits.into_iter() {
+            let name = router
+                .match_route(&req(&method, uri, None))
+                .unwrap()
+                .call(http::Request::new(()))
+                .await
+                .unwrap()
+                .into_body();
+            assert_eq!(name, svc_name);
         }
     }
 }
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/router.rs
index 76d3d69277..737a91148b 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/router.rs
@@ -5,14 +5,14 @@
 
 use crate::body::BoxBody;
 use crate::extension::RuntimeErrorExtension;
-use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::routing::{method_disallowed, UNKNOWN_OPERATION_EXCEPTION};
 
 use super::RestJson1;
 
 pub use crate::protocol::rest::router::*;
 
-impl IntoResponse<RestJson1> for Error {
+impl IntoResponseUniform<RestJson1> for Error {
     fn into_response(self) -> http::Response<BoxBody> {
         match self {
             Error::NotFound => http::Response::builder()
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/runtime_error.rs b/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/runtime_error.rs
index 5faf3ea8cf..792c3072dc 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/runtime_error.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/rest_json_1/runtime_error.rs
@@ -34,8 +34,10 @@ use super::rejection::ResponseRejection;
 use super::RestJson1;
 use crate::extension::RuntimeErrorExtension;
 use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::runtime_error::InternalFailureException;
 use crate::runtime_error::INVALID_HTTP_RESPONSE_FOR_RUNTIME_ERROR_PANIC_MESSAGE;
+use crate::service::ServiceShape;
 use http::StatusCode;
 
 #[derive(Debug)]
@@ -80,13 +82,25 @@ impl RuntimeError {
     }
 }
 
-impl IntoResponse<RestJson1> for InternalFailureException {
+impl<Ser, Op> IntoResponse<Ser, Op> for InternalFailureException {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
-        IntoResponse::<RestJson1>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
+        IntoResponseUniform::<RestJson1>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
     }
 }
 
-impl IntoResponse<RestJson1> for RuntimeError {
+impl<Ser, Op> IntoResponse<Ser, Op> for RuntimeError
+where
+    Ser: ServiceShape,
+    Self: IntoResponseUniform<Ser::Protocol>,
+{
+    fn into_response(self) -> http::Response<crate::body::BoxBody> {
+        IntoResponseUniform::<Ser::Protocol>::into_response(RuntimeError::InternalFailure(crate::Error::new(
+            String::new(),
+        )))
+    }
+}
+
+impl IntoResponseUniform<RestJson1> for RuntimeError {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
         let res = http::Response::builder()
             .status(self.status_code())
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/router.rs b/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/router.rs
index d8a0905a7f..1ded62867f 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/router.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/router.rs
@@ -6,7 +6,7 @@
 use crate::body::empty;
 use crate::body::BoxBody;
 use crate::extension::RuntimeErrorExtension;
-use crate::response::IntoResponse;
+use crate::response::IntoResponseUniform;
 use crate::routing::{method_disallowed, UNKNOWN_OPERATION_EXCEPTION};
 
 use super::RestXml;
@@ -14,7 +14,7 @@ use super::RestXml;
 pub use crate::protocol::rest::router::*;
 
 /// An AWS REST routing error.
-impl IntoResponse<RestXml> for Error {
+impl IntoResponseUniform<RestXml> for Error {
     fn into_response(self) -> http::Response<BoxBody> {
         match self {
             Error::NotFound => http::Response::builder()
diff --git a/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/runtime_error.rs b/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/runtime_error.rs
index d4ecb5c218..de73b062f8 100644
--- a/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/runtime_error.rs
+++ b/rust-runtime/aws-smithy-http-server/src/protocol/rest_xml/runtime_error.rs
@@ -4,8 +4,9 @@
  */
 
 use crate::protocol::rest_xml::RestXml;
-use crate::response::IntoResponse;
+use crate::response::{IntoResponse, IntoResponseUniform};
 use crate::runtime_error::InternalFailureException;
+use crate::service::ServiceShape;
 use crate::{extension::RuntimeErrorExtension, runtime_error::INVALID_HTTP_RESPONSE_FOR_RUNTIME_ERROR_PANIC_MESSAGE};
 use http::StatusCode;
 
@@ -42,13 +43,25 @@ impl RuntimeError {
     }
 }
 
-impl IntoResponse<RestXml> for InternalFailureException {
+impl IntoResponseUniform<RestXml> for InternalFailureException {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
-        IntoResponse::<RestXml>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
+        IntoResponseUniform::<RestXml>::into_response(RuntimeError::InternalFailure(crate::Error::new(String::new())))
     }
 }
 
-impl IntoResponse<RestXml> for RuntimeError {
+impl<Ser, Op> IntoResponse<Ser, Op> for RuntimeError
+where
+    Ser: ServiceShape,
+    Self: IntoResponseUniform<Ser::Protocol>,
+{
+    fn into_response(self) -> http::Response<crate::body::BoxBody> {
+        IntoResponseUniform::<Ser::Protocol>::into_response(RuntimeError::InternalFailure(crate::Error::new(
+            String::new(),
+        )))
+    }
+}
+
+impl IntoResponseUniform<RestXml> for RuntimeError {
     fn into_response(self) -> http::Response<crate::body::BoxBody> {
         let res = http::Response::builder()
             .status(self.status_code())
diff --git a/rust-runtime/aws-smithy-http-server/src/rejection.rs b/rust-runtime/aws-smithy-http-server/src/rejection.rs
index 1f1e247435..491c53d322 100644
--- a/rust-runtime/aws-smithy-http-server/src/rejection.rs
+++ b/rust-runtime/aws-smithy-http-server/src/rejection.rs
@@ -36,9 +36,9 @@ pub mod any_rejections {
                 $($var ($var),)*
             }
 
-            impl<P, $($var,)*> IntoResponse<P> for $name<$($var),*>
+            impl<Ser, Op, $($var,)*> IntoResponse<Ser, Op> for $name<$($var),*>
             where
-                $($var: IntoResponse<P>,)*
+                $($var: IntoResponse<Ser, Op>,)*
             {
                 #[allow(non_snake_case)]
                 fn into_response(self) -> http::Response<crate::body::BoxBody> {
diff --git a/rust-runtime/aws-smithy-http-server/src/request/connect_info.rs b/rust-runtime/aws-smithy-http-server/src/request/connect_info.rs
index 7a48e70421..8351ec408b 100644
--- a/rust-runtime/aws-smithy-http-server/src/request/connect_info.rs
+++ b/rust-runtime/aws-smithy-http-server/src/request/connect_info.rs
@@ -28,7 +28,7 @@ use super::{internal_server_error, FromParts};
 )]
 pub struct MissingConnectInfo;
 
-impl<Protocol> IntoResponse<Protocol> for MissingConnectInfo {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingConnectInfo {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
@@ -45,7 +45,7 @@ pub struct ConnectInfo<T>(
     pub T,
 );
 
-impl<P, T> FromParts<P> for ConnectInfo<T>
+impl<Ser, Op, T> FromParts<Ser, Op> for ConnectInfo<T>
 where
     T: Send + Sync + 'static,
 {
diff --git a/rust-runtime/aws-smithy-http-server/src/request/extension.rs b/rust-runtime/aws-smithy-http-server/src/request/extension.rs
index b7f10683eb..3b32aacd9a 100644
--- a/rust-runtime/aws-smithy-http-server/src/request/extension.rs
+++ b/rust-runtime/aws-smithy-http-server/src/request/extension.rs
@@ -81,13 +81,13 @@ impl<T> Deref for Extension<T> {
 #[error("the `Extension` is not present in the `http::Request`")]
 pub struct MissingExtension;
 
-impl<Protocol> IntoResponse<Protocol> for MissingExtension {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingExtension {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
 }
 
-impl<Protocol, T> FromParts<Protocol> for Extension<T>
+impl<Ser, Op, T> FromParts<Ser, Op> for Extension<T>
 where
     T: Send + Sync + 'static,
 {
diff --git a/rust-runtime/aws-smithy-http-server/src/request/lambda.rs b/rust-runtime/aws-smithy-http-server/src/request/lambda.rs
index 6088ee8f94..4321c2ba33 100644
--- a/rust-runtime/aws-smithy-http-server/src/request/lambda.rs
+++ b/rust-runtime/aws-smithy-http-server/src/request/lambda.rs
@@ -25,13 +25,13 @@ use crate::{body::BoxBody, response::IntoResponse};
 #[error("`Context` is not present in the `http::Request` extensions - consider using `aws_smithy_http_server::routing::LambdaHandler`")]
 pub struct MissingContext;
 
-impl<Protocol> IntoResponse<Protocol> for MissingContext {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingContext {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
 }
 
-impl<P> FromParts<P> for Context {
+impl<Ser, Op> FromParts<Ser, Op> for Context {
     type Rejection = MissingContext;
 
     fn from_parts(parts: &mut http::request::Parts) -> Result<Self, Self::Rejection> {
@@ -56,13 +56,13 @@ pub struct MissingGatewayContextV1 {
     inner: MissingGatewayContextTypeV1,
 }
 
-impl<Protocol> IntoResponse<Protocol> for MissingGatewayContextV1 {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingGatewayContextV1 {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
 }
 
-impl<P> FromParts<P> for ApiGatewayProxyRequestContext {
+impl<Ser, Op> FromParts<Ser, Op> for ApiGatewayProxyRequestContext {
     type Rejection = MissingGatewayContextV1;
 
     fn from_parts(parts: &mut http::request::Parts) -> Result<Self, Self::Rejection> {
@@ -96,13 +96,13 @@ pub struct MissingGatewayContextV2 {
     inner: MissingGatewayContextTypeV2,
 }
 
-impl<Protocol> IntoResponse<Protocol> for MissingGatewayContextV2 {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingGatewayContextV2 {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
 }
 
-impl<P> FromParts<P> for ApiGatewayV2httpRequestContext {
+impl<Ser, Op> FromParts<Ser, Op> for ApiGatewayV2httpRequestContext {
     type Rejection = MissingGatewayContextV2;
 
     fn from_parts(parts: &mut http::request::Parts) -> Result<Self, Self::Rejection> {
diff --git a/rust-runtime/aws-smithy-http-server/src/request/mod.rs b/rust-runtime/aws-smithy-http-server/src/request/mod.rs
index be507b804f..7bd95ff903 100644
--- a/rust-runtime/aws-smithy-http-server/src/request/mod.rs
+++ b/rust-runtime/aws-smithy-http-server/src/request/mod.rs
@@ -79,15 +79,15 @@ fn internal_server_error() -> http::Response<BoxBody> {
 
 /// Provides a protocol aware extraction from a [`Request`]. This borrows the [`Parts`], in contrast to
 /// [`FromRequest`] which consumes the entire [`http::Request`] including the body.
-pub trait FromParts<Protocol>: Sized {
+pub trait FromParts<Ser, Op>: Sized {
     /// The type of the extraction failures.
-    type Rejection: IntoResponse<Protocol>;
+    type Rejection: IntoResponse<Ser, Op>;
 
     /// Extracts `self` from a [`Parts`] synchronously.
     fn from_parts(parts: &mut Parts) -> Result<Self, Self::Rejection>;
 }
 
-impl<P> FromParts<P> for () {
+impl<Ser, Op> FromParts<Ser, Op> for () {
     type Rejection = Infallible;
 
     fn from_parts(_parts: &mut Parts) -> Result<Self, Self::Rejection> {
@@ -95,9 +95,9 @@ impl<P> FromParts<P> for () {
     }
 }
 
-impl<P, T> FromParts<P> for (T,)
+impl<Ser, Op, T> FromParts<Ser, Op> for (T,)
 where
-    T: FromParts<P>,
+    T: FromParts<Ser, Op>,
 {
     type Rejection = T::Rejection;
 
@@ -108,9 +108,9 @@ where
 
 macro_rules! impl_from_parts {
     ($error_name:ident, $($var:ident),+) => (
-        impl<P, $($var,)*> FromParts<P> for ($($var),*)
+        impl<Ser, Op, $($var,)*> FromParts<Ser, Op> for ($($var),*)
         where
-            $($var: FromParts<P>,)*
+            $($var: FromParts<Ser, Op>,)*
         {
             type Rejection = any_rejections::$error_name<$($var::Rejection),*>;
 
@@ -137,9 +137,9 @@ impl_from_parts!(Eight, A, B, C, D, E, F, G, H);
 ///
 /// This should not be implemented by hand. Code generation should implement this for your operations input. To extract
 /// items from a HTTP request [`FromParts`] should be used.
-pub trait FromRequest<Protocol, B>: Sized {
+pub trait FromRequest<Ser, Op, B>: Sized {
     /// The type of the extraction failures.
-    type Rejection: IntoResponse<Protocol>;
+    type Rejection: IntoResponse<Ser, Op>;
     /// The type of the extraction [`Future`].
     type Future: Future<Output = Result<Self, Self::Rejection>>;
 
@@ -147,39 +147,64 @@ pub trait FromRequest<Protocol, B>: Sized {
     fn from_request(request: Request<B>) -> Self::Future;
 }
 
-impl<P, B, T1> FromRequest<P, B> for (T1,)
-where
-    T1: FromRequest<P, B>,
-{
-    type Rejection = T1::Rejection;
-    type Future = MapOk<T1::Future, fn(T1) -> (T1,)>;
-
-    fn from_request(request: Request<B>) -> Self::Future {
-        T1::from_request(request).map_ok(|t1| (t1,))
-    }
-}
-
-impl<P, B, T1, T2> FromRequest<P, B> for (T1, T2)
-where
-    T1: FromRequest<P, B>,
-    T2: FromParts<P>,
-{
-    type Rejection = any_rejections::Two<T1::Rejection, T2::Rejection>;
-    type Future = TryJoin<MapErr<T1::Future, fn(T1::Rejection) -> Self::Rejection>, Ready<Result<T2, Self::Rejection>>>;
-
-    fn from_request(request: Request<B>) -> Self::Future {
-        let (mut parts, body) = request.into_parts();
-        let t2_result = T2::from_parts(&mut parts).map_err(any_rejections::Two::B);
-        try_join(
-            T1::from_request(Request::from_parts(parts, body)).map_err(any_rejections::Two::A),
-            ready(t2_result),
-        )
-    }
+macro_rules! impl_from_request {
+    ($($var:ident),*) => (
+        #[allow(unused_parens)]
+        impl<Ser, Op, B, T, $($var),*> FromRequest<Ser, Op, B> for (T, $($var),*)
+        where
+            T: FromRequest<Ser, Op, B>,
+            $(
+                $var: FromParts<Ser, Op>
+            ),*
+        {
+            type Rejection = any_rejections::Two<
+                T::Rejection,
+                <($($var),*) as FromParts<Ser, Op>>::Rejection
+            >;
+
+            type Future = MapOk<
+                TryJoin<
+                    MapErr<T::Future, fn(T::Rejection) -> Self::Rejection>,
+                    Ready<Result<($($var),*), Self::Rejection>>
+                >,
+                fn((T, ($($var),*))) -> Self
+            >;
+
+            #[allow(non_snake_case)]
+            fn from_request(request: Request<B>) -> Self::Future {
+                let (mut parts, body) = request.into_parts();
+                let vars = <($($var),*) as FromParts<Ser, Op>>::from_parts(&mut parts).map_err(any_rejections::Two::B);
+
+                let request = Request::from_parts(parts, body);
+                // This is required to coerce the closure
+                let map_err: fn(_) -> _ = |err| any_rejections::Two::A(err);
+                let t = T::from_request(request).map_err(map_err);
+                let closure: fn((T, ($($var),*))) -> (T, $($var),*) = |x| {
+                    let (t, ($($var),*)) = x;
+                    (t, $($var),*)
+                };
+                try_join(
+                    t,
+                    ready(vars)
+                ).map_ok(closure)
+            }
+        }
+    )
 }
 
-impl<P, T> FromParts<P> for Option<T>
+impl_from_request!();
+impl_from_request!(T0);
+impl_from_request!(T0, T1);
+impl_from_request!(T0, T1, T2);
+impl_from_request!(T0, T1, T2, T3);
+impl_from_request!(T0, T1, T2, T3, T4);
+impl_from_request!(T0, T1, T2, T3, T4, T5);
+impl_from_request!(T0, T1, T2, T3, T4, T5, T6);
+impl_from_request!(T0, T1, T2, T3, T4, T5, T6, T7);
+
+impl<Ser, Op, T> FromParts<Ser, Op> for Option<T>
 where
-    T: FromParts<P>,
+    T: FromParts<Ser, Op>,
 {
     type Rejection = Infallible;
 
@@ -188,9 +213,9 @@ where
     }
 }
 
-impl<P, T> FromParts<P> for Result<T, T::Rejection>
+impl<Ser, Op, T> FromParts<Ser, Op> for Result<T, T::Rejection>
 where
-    T: FromParts<P>,
+    T: FromParts<Ser, Op>,
 {
     type Rejection = Infallible;
 
diff --git a/rust-runtime/aws-smithy-http-server/src/request/request_id.rs b/rust-runtime/aws-smithy-http-server/src/request/request_id.rs
index 7d6ee70ab7..979f7ac3f3 100644
--- a/rust-runtime/aws-smithy-http-server/src/request/request_id.rs
+++ b/rust-runtime/aws-smithy-http-server/src/request/request_id.rs
@@ -92,7 +92,7 @@ impl Display for ServerRequestId {
     }
 }
 
-impl<P> FromParts<P> for ServerRequestId {
+impl<Ser, Op> FromParts<Ser, Op> for ServerRequestId {
     type Rejection = MissingServerRequestId;
 
     fn from_parts(parts: &mut Parts) -> Result<Self, Self::Rejection> {
@@ -188,7 +188,7 @@ where
     }
 }
 
-impl<Protocol> IntoResponse<Protocol> for MissingServerRequestId {
+impl<Ser, Op> IntoResponse<Ser, Op> for MissingServerRequestId {
     fn into_response(self) -> http::Response<BoxBody> {
         internal_server_error()
     }
diff --git a/rust-runtime/aws-smithy-http-server/src/response.rs b/rust-runtime/aws-smithy-http-server/src/response.rs
index 75a5be9759..938e562b66 100644
--- a/rust-runtime/aws-smithy-http-server/src/response.rs
+++ b/rust-runtime/aws-smithy-http-server/src/response.rs
@@ -37,13 +37,31 @@ use crate::body::BoxBody;
 pub type Response<T = BoxBody> = http::Response<T>;
 
 /// A protocol aware function taking `self` to [`http::Response`].
-pub trait IntoResponse<Protocol> {
+pub trait IntoResponse<Ser, Op> {
     /// Performs a conversion into a [`http::Response`].
     fn into_response(self) -> http::Response<BoxBody>;
 }
 
-impl<P> IntoResponse<P> for std::convert::Infallible {
+impl<Ser, Op> IntoResponse<Ser, Op> for std::convert::Infallible {
     fn into_response(self) -> http::Response<BoxBody> {
         match self {}
     }
 }
+
+impl<Ser, Op, T, E> IntoResponse<Ser, Op> for Result<T, E>
+where
+    T: IntoResponse<Ser, Op>,
+    E: IntoResponse<Ser, Op>,
+{
+    fn into_response(self) -> http::Response<BoxBody> {
+        match self {
+            Ok(ok) => ok.into_response(),
+            Err(err) => err.into_response(),
+        }
+    }
+}
+
+pub trait IntoResponseUniform<Protocol> {
+    /// Performs a conversion into a [`http::Response`].
+    fn into_response(self) -> http::Response<BoxBody>;
+}
diff --git a/rust-runtime/aws-smithy-http-server/src/routing/mod.rs b/rust-runtime/aws-smithy-http-server/src/routing/mod.rs
index 4f0cb8c0fa..cafe4ab68d 100644
--- a/rust-runtime/aws-smithy-http-server/src/routing/mod.rs
+++ b/rust-runtime/aws-smithy-http-server/src/routing/mod.rs
@@ -21,29 +21,18 @@ mod route;
 pub(crate) mod tiny_map;
 
 use std::{
+    convert::Infallible,
     error::Error,
     fmt,
-    future::{ready, Future, Ready},
-    marker::PhantomData,
+    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
 
-use bytes::Bytes;
-use futures_util::{
-    future::{Either, MapOk},
-    TryFutureExt,
-};
-use http::Response;
-use http_body::Body as HttpBody;
 use tower::{util::Oneshot, Service, ServiceExt};
 use tracing::debug;
 
-use crate::{
-    body::{boxed, BoxBody},
-    error::BoxError,
-    response::IntoResponse,
-};
+use crate::body::BoxBody;
 
 #[cfg(feature = "aws-lambda")]
 #[cfg_attr(docsrs, doc(cfg(feature = "aws-lambda")))]
@@ -67,7 +56,7 @@ pub(crate) fn method_disallowed() -> http::Response<BoxBody> {
 
 /// An interface for retrieving an inner [`Service`] given a [`http::Request`].
 pub trait Router<B> {
-    type Service;
+    type Service: Service<http::Request<B>, Error = Infallible>;
     type Error;
 
     /// Matches a [`http::Request`] to a target [`Service`].
@@ -77,114 +66,103 @@ pub trait Router<B> {
 /// A [`Service`] using the [`Router`] `R` to redirect messages to specific routes.
 ///
 /// The `Protocol` parameter is used to determine the serialization of errors.
-pub struct RoutingService<R, Protocol> {
+pub struct RoutingService<R> {
     router: R,
-    _protocol: PhantomData<Protocol>,
 }
 
-impl<R, P> fmt::Debug for RoutingService<R, P>
+impl<R> fmt::Debug for RoutingService<R>
 where
     R: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("RoutingService")
-            .field("router", &self.router)
-            .field("_protocol", &self._protocol)
-            .finish()
+        f.debug_struct("RoutingService").field("router", &self.router).finish()
     }
 }
 
-impl<R, P> Clone for RoutingService<R, P>
+impl<R> Clone for RoutingService<R>
 where
     R: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             router: self.router.clone(),
-            _protocol: PhantomData,
         }
     }
 }
 
-impl<R, P> RoutingService<R, P> {
+impl<R> RoutingService<R> {
     /// Creates a [`RoutingService`] from a [`Router`].
     pub fn new(router: R) -> Self {
-        Self {
-            router,
-            _protocol: PhantomData,
-        }
+        Self { router }
     }
+}
 
-    /// Maps a [`Router`] using a closure.
-    pub fn map<RNew, F>(self, f: F) -> RoutingService<RNew, P>
-    where
-        F: FnOnce(R) -> RNew,
-    {
-        RoutingService {
-            router: f(self.router),
-            _protocol: PhantomData,
-        }
+pin_project_lite::pin_project! {
+    #[project = RoutingFutureInnerProj]
+    enum RoutingFutureInner<B, R> where R: Router<B> {
+        Oneshot {
+            #[pin]
+            oneshot: Oneshot<R::Service, http::Request<B>>
+        },
+        Error { error: Option<R::Error> }
     }
 }
 
-type EitherOneshotReady<S, B> = Either<
-    MapOk<Oneshot<S, http::Request<B>>, fn(<S as Service<http::Request<B>>>::Response) -> http::Response<BoxBody>>,
-    Ready<Result<http::Response<BoxBody>, <S as Service<http::Request<B>>>::Error>>,
->;
-
 pin_project_lite::pin_project! {
-    pub struct RoutingFuture<S, B> where S: Service<http::Request<B>> {
+    pub struct RoutingFuture<B, R> where R: Router<B> {
         #[pin]
-        inner: EitherOneshotReady<S, B>
+        inner: RoutingFutureInner<B, R>
     }
 }
 
-impl<S, B> RoutingFuture<S, B>
+impl<B, R> RoutingFuture<B, R>
 where
-    S: Service<http::Request<B>>,
+    R: Router<B>,
 {
     /// Creates a [`RoutingFuture`] from [`ServiceExt::oneshot`].
-    pub(super) fn from_oneshot<RespB>(future: Oneshot<S, http::Request<B>>) -> Self
-    where
-        S: Service<http::Request<B>, Response = http::Response<RespB>>,
-        RespB: HttpBody<Data = Bytes> + Send + 'static,
-        RespB::Error: Into<BoxError>,
-    {
+    pub(super) fn from_oneshot(oneshot: Oneshot<R::Service, http::Request<B>>) -> Self {
         Self {
-            inner: Either::Left(future.map_ok(|x| x.map(boxed))),
+            inner: RoutingFutureInner::Oneshot { oneshot },
         }
     }
 
     /// Creates a [`RoutingFuture`] from [`Service::Response`].
-    pub(super) fn from_response(response: http::Response<BoxBody>) -> Self {
+    pub(super) fn from_error(error: R::Error) -> Self {
         Self {
-            inner: Either::Right(ready(Ok(response))),
+            inner: RoutingFutureInner::Error { error: Some(error) },
         }
     }
 }
 
-impl<S, B> Future for RoutingFuture<S, B>
+impl<B, R> Future for RoutingFuture<B, R>
 where
-    S: Service<http::Request<B>>,
+    R: Router<B>,
 {
-    type Output = Result<http::Response<BoxBody>, S::Error>;
+    type Output = Result<<R::Service as Service<http::Request<B>>>::Response, R::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().inner.poll(cx)
+        let this = self.project();
+        let inner = this.inner.project();
+        use RoutingFutureInnerProj::*;
+        match inner {
+            Oneshot { oneshot } => oneshot.poll(cx).map_err(|err| match err {}),
+            Error { error } => {
+                let error = error.take().expect("futures should not be polled after completion");
+                Poll::Ready(Err(error))
+            }
+        }
     }
 }
 
-impl<R, P, B, RespB> Service<http::Request<B>> for RoutingService<R, P>
+impl<R, B> Service<http::Request<B>> for RoutingService<R>
 where
     R: Router<B>,
-    R::Service: Service<http::Request<B>, Response = http::Response<RespB>> + Clone,
-    R::Error: IntoResponse<P> + Error,
-    RespB: HttpBody<Data = Bytes> + Send + 'static,
-    RespB::Error: Into<BoxError>,
+    R::Service: Clone,
+    R::Error: Error,
 {
-    type Response = Response<BoxBody>;
-    type Error = <R::Service as Service<http::Request<B>>>::Error;
-    type Future = RoutingFuture<R::Service, B>;
+    type Response = <R::Service as Service<http::Request<B>>>::Response;
+    type Error = R::Error;
+    type Future = RoutingFuture<B, R>;
 
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
@@ -197,7 +175,7 @@ where
             // Failed to route, use the `R::Error`s `IntoResponse<P>`.
             Err(error) => {
                 debug!(%error, "failed to route");
-                RoutingFuture::from_response(error.into_response())
+                RoutingFuture::from_error(error)
             }
         }
     }