diff --git a/rama-http/src/layer/upgrade/service.rs b/rama-http/src/layer/upgrade/service.rs
index d21adcc8b..eaf030fae 100644
--- a/rama-http/src/layer/upgrade/service.rs
+++ b/rama-http/src/layer/upgrade/service.rs
@@ -125,7 +125,7 @@ pub struct UpgradeHandler<O> {
 
 enum UpgradeHandlerKind<O> {
     ResponseLocal {
-        responder: BoxService<Request, UpgradeOutput<Request, O>, O>,
+        responder: ResponseLocalResponder<O>,
         handler_error_sink: Arc<dyn ErrorSink>,
     },
     SeparateServices {
@@ -149,6 +149,13 @@ struct PreparedUpgrade<O> {
     continuation: UpgradeContinuation,
 }
 
+type ResponseLocalResponderFuture<O> =
+    Pin<Box<dyn Future<Output = Result<UpgradeOutput<Request, O>, O>> + Send + 'static>>;
+// Keep the generic `R: Service` predicate outside the erased call boundary.
+// Rust 1.98 can otherwise emit a vacant `BoxService` vtable entry here.
+type ResponseLocalResponder<O> =
+    Arc<dyn Fn(Request) -> ResponseLocalResponderFuture<O> + Send + Sync + 'static>;
+
 impl<O: Send + 'static> UpgradeHandler<O> {
     /// Register one service which returns its response-local upgrade handler.
     pub(crate) fn new<M, R, Sink>(matcher: M, responder: R, sink: Sink) -> Self
@@ -157,10 +164,15 @@ impl<O: Send + 'static> UpgradeHandler<O> {
         R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone,
         Sink: ErrorSink,
     {
+        let responder: ResponseLocalResponder<O> = Arc::new(move |request| {
+            let responder = responder.clone();
+            Box::pin(async move { responder.serve(request).await })
+        });
+
         Self {
             matcher: Box::new(matcher),
             kind: UpgradeHandlerKind::ResponseLocal {
-                responder: responder.boxed(),
+                responder,
                 handler_error_sink: Arc::new(sink),
             },
             _phantom: std::marker::PhantomData,
@@ -203,7 +215,7 @@ impl<O: Send + 'static> UpgradeHandler<O> {
             UpgradeHandlerKind::ResponseLocal {
                 responder,
                 handler_error_sink,
-            } => responder.serve(request).await.map(
+            } => responder(request).await.map(
                 |UpgradeOutput {
                      response,
                      request,

diff --git a/rama-core/src/service/svc.rs b/rama-core/src/service/svc.rs
--- a/rama-core/src/service/svc.rs
+++ b/rama-core/src/service/svc.rs
@@ -1,5 +1,6 @@
 //! [`Service`] and [`BoxService`] traits.
 
+use core::any::Any;
 use core::convert::Infallible;
 use core::fmt;
 use core::marker::PhantomData;
@@ -145,46 +146,41 @@ where
     }
 }
 
-/// Internal trait for dynamic dispatch of Async Traits,
-/// implemented according to the pioneers of this Design Pattern
-/// found at <https://rust-lang.github.io/async-fundamentals-initiative/evaluation/case-studies/builder-provider-api.html#dynamic-dispatch-behind-the-api>
-/// and widely published at <https://blog.rust-lang.org/inside-rust/2023/05/03/stabilizing-async-fn-in-trait.html>.
-trait DynService<Input> {
-    type Output;
-    type Error;
-
-    #[expect(clippy::type_complexity)]
-    fn serve_box(
-        &self,
-        input: Input,
-    ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + '_>>;
-}
+// Keep dispatch separate from the erased value's vtable. Rust 1.98 can emit a
+// vacant method slot for the custom async-erasure trait with complex services.
+type ErasedService = dyn Any + Send + Sync + 'static;
+type BoxServiceFuture<'a, Output, Error> =
+    Pin<Box<dyn Future<Output = Result<Output, Error>> + Send + 'a>>;
+type ServeErasedFn<Input, Output, Error> =
+    for<'a> fn(&'a ErasedService, Input) -> BoxServiceFuture<'a, Output, Error>;
 
-impl<Input, T> DynService<Input> for T
+fn serve_erased<'a, Input, Output, Error, T>(
+    inner: &'a ErasedService,
+    input: Input,
+) -> BoxServiceFuture<'a, Output, Error>
 where
-    T: Service<Input>,
+    T: Service<Input, Output = Output, Error = Error>,
 {
-    type Output = T::Output;
-    type Error = T::Error;
-
-    fn serve_box(
-        &self,
-        input: Input,
-    ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + '_>> {
-        Box::pin(self.serve(input))
-    }
+    #[expect(
+        clippy::unwrap_used,
+        reason = "the constructor stores the same service type as its dispatch function"
+    )]
+    let service = inner.downcast_ref::<T>().unwrap();
+    Box::pin(service.serve(input))
 }
 
 /// A boxed [`Service`], to serve Inputs with,
 /// for where you inputuire dynamic dispatch.
 pub struct BoxService<Input, Output, Error> {
-    inner: Arc<dyn DynService<Input, Output = Output, Error = Error> + Send + Sync + 'static>,
+    inner: Arc<ErasedService>,
+    serve: ServeErasedFn<Input, Output, Error>,
 }
 
 impl<Input, Output, Error> Clone for BoxService<Input, Output, Error> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
+            serve: self.serve,
         }
     }
 }
@@ -198,6 +194,7 @@ impl<Input, Output, Error> BoxService<Input, Output, Error> {
     {
         Self {
             inner: Arc::new(service),
+            serve: serve_erased::<Input, Output, Error, T>,
         }
     }
 }
@@ -223,7 +220,7 @@ where
 
         input: Input,
     ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_ {
-        self.inner.serve_box(input)
+        (self.serve)(self.inner.as_ref(), input)
     }
 
     #[inline]