diff --git a/examples/actix-web/src/main.rs b/examples/actix-web/src/main.rs
index a4b73b6..472eec8 100644
--- a/examples/actix-web/src/main.rs
+++ b/examples/actix-web/src/main.rs
@@ -17,7 +17,7 @@ async fn push_email(
     let mut storage = storage.clone();
     let res = storage.push(email.into_inner()).await;
     match res {
-        Ok(jid) => HttpResponse::Ok().body(format!("Email with job_id [{jid}] added to queue")),
+        Ok(ctx) => HttpResponse::Ok().json(ctx),
         Err(e) => HttpResponse::InternalServerError().body(format!("{e}")),
     }
 }
@@ -46,7 +46,6 @@ async fn main() -> Result<()> {
             WorkerBuilder::new("tasty-avocado")
                 .layer(TraceLayer::new())
                 .backend(storage)
-                // .chain(|svc|svc.map_err(|e| Box::new(e)))
                 .build_fn(send_email)
         })
         .run_with_signal(signal::ctrl_c());
diff --git a/examples/async-std-runtime/src/main.rs b/examples/async-std-runtime/src/main.rs
index 58f2afa..0b9c7ad 100644
--- a/examples/async-std-runtime/src/main.rs
+++ b/examples/async-std-runtime/src/main.rs
@@ -9,7 +9,7 @@ use apalis_cron::{CronStream, Schedule};
 use chrono::{DateTime, Utc};
 use tracing::{debug, info, Instrument, Level, Span};
 
-type WorkerCtx = Context<AsyncStdExecutor>;
+type WorkerCtx = Data<Context<AsyncStdExecutor>>;
 
 #[derive(Default, Debug, Clone)]
 struct Reminder(DateTime<Utc>);
@@ -48,7 +48,7 @@ async fn main() -> Result<()> {
         .build_fn(send_reminder);
 
     Monitor::<AsyncStdExecutor>::new()
-        .register_with_count(2, worker)
+        .register(worker)
         .on_event(|e| debug!("Worker event: {e:?}"))
         .run_with_signal(async {
             ctrl_c.recv().await.ok();
@@ -95,10 +95,10 @@ impl ReminderSpan {
     }
 }
 
-impl<B> MakeSpan<B> for ReminderSpan {
-    fn make_span(&mut self, req: &Request<B>) -> Span {
-        let task_id: &TaskId = req.get().unwrap();
-        let attempts: Attempt = req.get().cloned().unwrap_or_default();
+impl<B, Ctx> MakeSpan<B, Ctx> for ReminderSpan {
+    fn make_span(&mut self, req: &Request<B, Ctx>) -> Span {
+        let task_id: &TaskId = &req.parts.task_id;
+        let attempts: &Attempt = &req.parts.attempt;
         let span = Span::current();
         macro_rules! make_span {
             ($level:expr) => {
diff --git a/examples/axum/src/main.rs b/examples/axum/src/main.rs
index a3d7774..3e0e4da 100644
--- a/examples/axum/src/main.rs
+++ b/examples/axum/src/main.rs
@@ -36,9 +36,9 @@ where
     let new_job = storage.push(input).await;
 
     match new_job {
-        Ok(id) => (
+        Ok(ctx) => (
             StatusCode::CREATED,
-            format!("Job [{id}] was successfully added"),
+            format!("Job [{ctx:?}] was successfully added"),
         ),
         Err(e) => (
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -74,7 +74,7 @@ async fn main() -> Result<()> {
     };
     let monitor = async {
         Monitor::<TokioExecutor>::new()
-            .register_with_count(2, {
+            .register({
                 WorkerBuilder::new("tasty-pear")
                     .layer(TraceLayer::new())
                     .backend(storage.clone())
diff --git a/examples/basics/Cargo.toml b/examples/basics/Cargo.toml
index feade0b..30ab492 100644
--- a/examples/basics/Cargo.toml
+++ b/examples/basics/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 thiserror = "1"
 tokio = { version = "1", features = ["full"] }
 apalis = { path = "../../", features = ["limit", "tokio-comp", "catch-panic"] }
-apalis-sql = { path = "../../packages/apalis-sql" }
+apalis-sql = { path = "../../packages/apalis-sql", features = ["sqlite"] }
 serde = "1"
 tracing-subscriber = "0.3.11"
 email-service = { path = "../email-service" }
diff --git a/examples/basics/src/layer.rs b/examples/basics/src/layer.rs
index 2918346..d8da32a 100644
--- a/examples/basics/src/layer.rs
+++ b/examples/basics/src/layer.rs
@@ -1,4 +1,7 @@
-use std::task::{Context, Poll};
+use std::{
+    fmt::Debug,
+    task::{Context, Poll},
+};
 
 use apalis::prelude::Request;
 use tower::{Layer, Service};
@@ -34,10 +37,11 @@ pub struct LogService<S> {
     service: S,
 }
 
-impl<S, Req> Service<Request<Req>> for LogService<S>
+impl<S, Req, Ctx> Service<Request<Req, Ctx>> for LogService<S>
 where
-    S: Service<Request<Req>> + Clone,
-    Req: std::fmt::Debug,
+    S: Service<Request<Req, Ctx>> + Clone,
+    Req: Debug,
+    Ctx: Debug,
 {
     type Response = S::Response;
     type Error = S::Error;
@@ -47,7 +51,7 @@ where
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, request: Request<Req>) -> Self::Future {
+    fn call(&mut self, request: Request<Req, Ctx>) -> Self::Future {
         // Use service to apply middleware before or(and) after a request
         info!("request = {:?}, target = {:?}", request, self.target);
         self.service.call(request)
diff --git a/examples/basics/src/main.rs b/examples/basics/src/main.rs
index e6b1f0c..ff49244 100644
--- a/examples/basics/src/main.rs
+++ b/examples/basics/src/main.rs
@@ -2,7 +2,7 @@ mod cache;
 mod layer;
 mod service;
 
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 
 use apalis::{
     layers::{catch_panic::CatchPanicLayer, tracing::TraceLayer},
@@ -35,7 +35,7 @@ async fn produce_jobs(storage: &SqliteStorage<Email>) {
 }
 
 #[derive(thiserror::Error, Debug)]
-pub enum Error {
+pub enum ServiceError {
     #[error("data store disconnected")]
     Disconnect(#[from] std::io::Error),
     #[error("the data for key `{0}` is not available")]
@@ -46,15 +46,21 @@ pub enum Error {
     Unknown,
 }
 
+#[derive(thiserror::Error, Debug)]
+pub enum PanicError {
+    #[error("{0}")]
+    Panic(String),
+}
+
 /// Quick solution to prevent spam.
 /// If email in cache, then send email else complete the job but let a validation process run in the background,
 async fn send_email(
     email: Email,
     svc: Data<EmailService>,
     worker_ctx: Data<WorkerCtx>,
-    worker_id: WorkerId,
+    worker_id: Data<WorkerId>,
     cache: Data<ValidEmailCache>,
-) -> Result<(), Error> {
+) -> Result<(), ServiceError> {
     info!("Job started in worker {:?}", worker_id);
     let cache_clone = cache.clone();
     let email_to = email.to.clone();
@@ -97,10 +103,19 @@ async fn main() -> Result<(), std::io::Error> {
     produce_jobs(&sqlite).await;
 
     Monitor::<TokioExecutor>::new()
-        .register_with_count(2, {
+        .register({
             WorkerBuilder::new("tasty-banana")
                 // This handles any panics that may occur in any of the layers below
-                .layer(CatchPanicLayer::new())
+                .layer(CatchPanicLayer::with_panic_handler(|e| {
+                    let panic_info = if let Some(s) = e.downcast_ref::<&str>() {
+                        s.to_string()
+                    } else if let Some(s) = e.downcast_ref::<String>() {
+                        s.clone()
+                    } else {
+                        "Unknown panic".to_string()
+                    };
+                    Error::Abort(Arc::new(Box::new(PanicError::Panic(panic_info))))
+                }))
                 .layer(TraceLayer::new())
                 .layer(LogLayer::new("some-log-example"))
                 // Add shared context to all jobs executed by this worker
diff --git a/examples/cron/Cargo.toml b/examples/cron/Cargo.toml
index 070ac49..ab3218d 100644
--- a/examples/cron/Cargo.toml
+++ b/examples/cron/Cargo.toml
@@ -9,6 +9,7 @@ apalis = { path = "../../", default-features = false, features = [
     "tokio-comp",
     "tracing",
     "limit",
+    "catch-panic"
 ] }
 apalis-cron = { path = "../../packages/apalis-cron" }
 tokio = { version = "1", features = ["full"] }
diff --git a/examples/cron/src/main.rs b/examples/cron/src/main.rs
index 4a8fb74..4a22dfe 100644
--- a/examples/cron/src/main.rs
+++ b/examples/cron/src/main.rs
@@ -1,3 +1,4 @@
+use apalis::layers::tracing::TraceLayer;
 use apalis::prelude::*;
 use apalis::utils::TokioExecutor;
 use apalis_cron::CronStream;
@@ -31,13 +32,14 @@ async fn send_reminder(job: Reminder, svc: Data<FakeService>) {
 async fn main() {
     let schedule = Schedule::from_str("1/1 * * * * *").unwrap();
     let worker = WorkerBuilder::new("morning-cereal")
+        .layer(TraceLayer::new())
         .layer(LoadShedLayer::new()) // Important when you have layers that block the service
         .layer(RateLimitLayer::new(1, Duration::from_secs(2)))
         .data(FakeService)
         .backend(CronStream::new(schedule))
         .build_fn(send_reminder);
     Monitor::<TokioExecutor>::new()
-        .register(worker)
+        .register_with_count(2, worker)
         .run()
         .await
         .unwrap();
diff --git a/examples/fn-args/src/main.rs b/examples/fn-args/src/main.rs
index 5fd614c..4a28d28 100644
--- a/examples/fn-args/src/main.rs
+++ b/examples/fn-args/src/main.rs
@@ -20,16 +20,16 @@ struct SimpleJob {}
 // A task can have up to 16 arguments
 async fn simple_job(
     _: SimpleJob,                        // Required, must be of the type of the job/message
-    worker_id: WorkerId,                 // The worker running the job, added by worker
+    worker_id: Data<WorkerId>,           // The worker running the job, added by worker
     _worker_ctx: Context<TokioExecutor>, // The worker context, added by worker
     _sqlite: Data<SqliteStorage<SimpleJob>>, // The source, added by storage
     task_id: Data<TaskId>,               // The task id, added by storage
-    ctx: Data<SqlContext>,               // The task context, added by storage
+    ctx: SqlContext,                     // The task context
     count: Data<Count>,                  // Our custom data added via layer
 ) {
     // increment the counter
     let current = count.fetch_add(1, Ordering::Relaxed);
-    info!("worker: {worker_id}; task_id: {task_id:?}, ctx: {ctx:?}, count: {current:?}");
+    info!("worker: {worker_id:?}; task_id: {task_id:?}, ctx: {ctx:?}, count: {current:?}");
 }
 
 async fn produce_jobs(storage: &mut SqliteStorage<SimpleJob>) {
diff --git a/examples/prometheus/src/main.rs b/examples/prometheus/src/main.rs
index 160dfc5..eaa334a 100644
--- a/examples/prometheus/src/main.rs
+++ b/examples/prometheus/src/main.rs
@@ -49,9 +49,9 @@ async fn main() -> Result<()> {
     };
     let monitor = async {
         Monitor::<TokioExecutor>::new()
-            .register_with_count(2, {
+            .register({
                 WorkerBuilder::new("tasty-banana")
-                    .layer(PrometheusLayer)
+                    .layer(PrometheusLayer::default())
                     .backend(storage.clone())
                     .build_fn(send_email)
             })
@@ -94,9 +94,9 @@ where
     let new_job = storage.push(input).await;
 
     match new_job {
-        Ok(jid) => (
+        Ok(ctx) => (
             StatusCode::CREATED,
-            format!("Job [{jid}] was successfully added"),
+            format!("Job [{ctx:?}] was successfully added"),
         ),
         Err(e) => (
             StatusCode::INTERNAL_SERVER_ERROR,
diff --git a/examples/redis-deadpool/src/main.rs b/examples/redis-deadpool/src/main.rs
index 0d0d756..9d62593 100644
--- a/examples/redis-deadpool/src/main.rs
+++ b/examples/redis-deadpool/src/main.rs
@@ -31,7 +31,7 @@ async fn main() -> Result<()> {
         .build_fn(send_email);
 
     Monitor::<TokioExecutor>::new()
-        .register_with_count(2, worker)
+        .register(worker)
         .shutdown_timeout(Duration::from_millis(5000))
         .run_with_signal(async {
             tokio::signal::ctrl_c().await?;
diff --git a/examples/redis-mq-example/src/main.rs b/examples/redis-mq-example/src/main.rs
index 1b3f245..5f8f740 100644
--- a/examples/redis-mq-example/src/main.rs
+++ b/examples/redis-mq-example/src/main.rs
@@ -2,16 +2,17 @@ use std::{fmt::Debug, marker::PhantomData, time::Duration};
 
 use apalis::{layers::tracing::TraceLayer, prelude::*};
 
-use apalis_redis::{self, Config, RedisJob};
+use apalis_redis::{self, Config};
 
 use apalis_core::{
     codec::json::JsonCodec,
     layers::{Ack, AckLayer},
+    response::Response,
 };
 use email_service::{send_email, Email};
 use futures::{channel::mpsc, SinkExt};
 use rsmq_async::{Rsmq, RsmqConnection, RsmqError};
-use serde::{de::DeserializeOwned, Serialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use tokio::time::sleep;
 use tracing::{error, info};
 
@@ -22,6 +23,18 @@ struct RedisMq<T, C = JsonCodec<Vec<u8>>> {
     codec: PhantomData<C>,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+pub struct RedisMqContext {
+    max_attempts: usize,
+    message_id: String,
+}
+
+impl<Req> FromRequest<Request<Req, RedisMqContext>> for RedisMqContext {
+    fn from_request(req: &Request<Req, RedisMqContext>) -> Result<Self, Error> {
+        Ok(req.parts.context.clone())
+    }
+}
+
 // Manually implement Clone for RedisMq
 impl<T, C> Clone for RedisMq<T, C> {
     fn clone(&self) -> Self {
@@ -34,32 +47,30 @@ impl<T, C> Clone for RedisMq<T, C> {
     }
 }
 
-impl<M, C, Res> Backend<Request<M>, Res> for RedisMq<M, C>
+impl<Req, C, Res> Backend<Request<Req, RedisMqContext>, Res> for RedisMq<Req, C>
 where
-    M: Send + DeserializeOwned + 'static,
+    Req: Send + DeserializeOwned + 'static,
     C: Codec<Compact = Vec<u8>>,
 {
-    type Stream = RequestStream<Request<M>>;
+    type Stream = RequestStream<Request<Req, RedisMqContext>>;
 
-    type Layer = AckLayer<Self, M, Res>;
+    type Layer = AckLayer<Self, Req, RedisMqContext, Res>;
 
     fn poll<Svc>(mut self, _worker_id: WorkerId) -> Poller<Self::Stream, Self::Layer> {
         let (mut tx, rx) = mpsc::channel(self.config.get_buffer_size());
-        let stream: RequestStream<Request<M>> = Box::pin(rx);
+        let stream: RequestStream<Request<Req, RedisMqContext>> = Box::pin(rx);
         let layer = AckLayer::new(self.clone());
         let heartbeat = async move {
             loop {
                 sleep(*self.config.get_poll_interval()).await;
-                let msg: Option<Request<M>> = self
+                let msg: Option<Request<Req, RedisMqContext>> = self
                     .conn
                     .receive_message(self.config.get_namespace(), None)
                     .await
                     .unwrap()
                     .map(|r| {
-                        let mut req: Request<M> = C::decode::<RedisJob<M>>(r.message)
-                            .map_err(Into::into)
-                            .unwrap()
-                            .into();
+                        let mut req: Request<Req, RedisMqContext> =
+                            C::decode(r.message).map_err(Into::into).unwrap();
                         req.insert(r.id);
                         req
                     });
@@ -76,18 +87,20 @@ where
     Res: Debug + Send + Sync,
     C: Send,
 {
-    type Context = String;
+    type Context = RedisMqContext;
 
     type AckError = RsmqError;
 
     async fn ack(
         &mut self,
         ctx: &Self::Context,
-        _res: &Result<Res, apalis_core::error::Error>,
+        res: &Response<Res>,
     ) -> Result<(), Self::AckError> {
-        self.conn
-            .delete_message(self.config.get_namespace(), ctx)
-            .await?;
+        if res.is_success() || res.attempt.current() >= ctx.max_attempts {
+            self.conn
+                .delete_message(self.config.get_namespace(), &ctx.message_id)
+                .await?;
+        }
         Ok(())
     }
 }
@@ -100,7 +113,7 @@ where
     type Error = RsmqError;
 
     async fn enqueue(&mut self, message: Message) -> Result<(), Self::Error> {
-        let bytes = C::encode(&RedisJob::new(message, Default::default()))
+        let bytes = C::encode(&Request::<Message, RedisMqContext>::new(message))
             .map_err(Into::into)
             .unwrap();
         self.conn
@@ -115,11 +128,9 @@ where
             .receive_message(self.config.get_namespace(), None)
             .await?
             .map(|r| {
-                let req: Request<Message> = C::decode::<RedisJob<Message>>(r.message)
-                    .map_err(Into::into)
-                    .unwrap()
-                    .into();
-                req.take()
+                let req: Request<Message, RedisMqContext> =
+                    C::decode(r.message).map_err(Into::into).unwrap();
+                req.args
             }))
     }
 
diff --git a/examples/redis-with-msg-pack/src/main.rs b/examples/redis-with-msg-pack/src/main.rs
index 1ac2e24..ce5e57a 100644
--- a/examples/redis-with-msg-pack/src/main.rs
+++ b/examples/redis-with-msg-pack/src/main.rs
@@ -45,7 +45,7 @@ async fn main() -> Result<()> {
         .build_fn(send_email);
 
     Monitor::<TokioExecutor>::new()
-        .register_with_count(2, worker)
+        .register(worker)
         .shutdown_timeout(Duration::from_millis(5000))
         .run_with_signal(async {
             tokio::signal::ctrl_c().await?;
diff --git a/examples/redis/src/main.rs b/examples/redis/src/main.rs
index 5e0723e..32a16a3 100644
--- a/examples/redis/src/main.rs
+++ b/examples/redis/src/main.rs
@@ -1,7 +1,9 @@
-use std::{sync::Arc, time::Duration};
+use std::time::Duration;
 
 use anyhow::Result;
-use apalis::layers::limit::RateLimitLayer;
+use apalis::layers::limit::{ConcurrencyLimitLayer, RateLimitLayer};
+use apalis::layers::tracing::TraceLayer;
+use apalis::layers::ErrorHandlingLayer;
 use apalis::{layers::TimeoutLayer, prelude::*};
 use apalis_redis::RedisStorage;
 
@@ -33,14 +35,16 @@ async fn main() -> Result<()> {
     produce_jobs(storage.clone()).await?;
 
     let worker = WorkerBuilder::new("rango-tango")
-        .chain(|svc| svc.map_err(|e| Error::Failed(Arc::new(e))))
+        .layer(ErrorHandlingLayer::new())
+        .layer(TraceLayer::new())
         .layer(RateLimitLayer::new(5, Duration::from_secs(1)))
         .layer(TimeoutLayer::new(Duration::from_millis(500)))
+        .layer(ConcurrencyLimitLayer::new(2))
         .backend(storage)
         .build_fn(send_email);
 
     Monitor::<TokioExecutor>::new()
-        .register_with_count(2, worker)
+        .register(worker)
         .on_event(|e| {
             let worker_id = e.id();
             match e.inner() {
diff --git a/examples/sqlite/Cargo.toml b/examples/sqlite/Cargo.toml
index b3a4cf9..5a58b2d 100644
--- a/examples/sqlite/Cargo.toml
+++ b/examples/sqlite/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 anyhow = "1"
 tokio = { version = "1", features = ["full"] }
 apalis = { path = "../../", features = ["limit", "tracing", "tokio-comp"] }
-apalis-sql = { path = "../../packages/apalis-sql", features = ["sqlite"] }
+apalis-sql = { path = "../../packages/apalis-sql", features = ["sqlite", "tokio-comp"] }
 serde = { version = "1", features = ["derive"] }
 tracing-subscriber = "0.3.11"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
diff --git a/examples/sqlite/src/main.rs b/examples/sqlite/src/main.rs
index 282898b..802a4ff 100644
--- a/examples/sqlite/src/main.rs
+++ b/examples/sqlite/src/main.rs
@@ -59,15 +59,15 @@ async fn main() -> Result<()> {
     produce_notifications(&notification_storage).await?;
 
     Monitor::<TokioExecutor>::new()
-        .register_with_count(2, {
+        .register({
             WorkerBuilder::new("tasty-banana")
                 .layer(TraceLayer::new())
                 .backend(email_storage)
                 .build_fn(send_email)
         })
-        .register_with_count(10, {
+        .register({
             WorkerBuilder::new("tasty-mango")
-                .layer(TraceLayer::new())
+                // .layer(TraceLayer::new())
                 .backend(notification_storage)
                 .build_fn(job::notify)
         })
diff --git a/packages/apalis-core/src/builder.rs b/packages/apalis-core/src/builder.rs
index 6ed8d3f..bc9bd21 100644
--- a/packages/apalis-core/src/builder.rs
+++ b/packages/apalis-core/src/builder.rs
@@ -18,16 +18,16 @@ use crate::{
 
 /// Allows building a [`Worker`].
 /// Usually the output is [`Worker<Ready>`]
-pub struct WorkerBuilder<Req, Source, Middleware, Serv> {
+pub struct WorkerBuilder<Req, Ctx, Source, Middleware, Serv> {
     id: WorkerId,
-    request: PhantomData<Req>,
+    request: PhantomData<Request<Req, Ctx>>,
     layer: ServiceBuilder<Middleware>,
     source: Source,
     service: PhantomData<Serv>,
 }
 
-impl<Req, Source, Middleware, Serv> std::fmt::Debug
-    for WorkerBuilder<Req, Source, Middleware, Serv>
+impl<Req, Ctx, Source, Middleware, Serv> std::fmt::Debug
+    for WorkerBuilder<Req, Ctx, Source, Middleware, Serv>
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("WorkerBuilder")
@@ -39,10 +39,10 @@ impl<Req, Source, Middleware, Serv> std::fmt::Debug
     }
 }
 
-impl<Serv> WorkerBuilder<(), (), Identity, Serv> {
+impl<Serv> WorkerBuilder<(), (), (), Identity, Serv> {
     /// Build a new [`WorkerBuilder`] instance with a name for the worker to build
-    pub fn new<T: AsRef<str>>(name: T) -> WorkerBuilder<(), (), Identity, Serv> {
-        let job: PhantomData<()> = PhantomData;
+    pub fn new<T: AsRef<str>>(name: T) -> WorkerBuilder<(), (), (), Identity, Serv> {
+        let job: PhantomData<Request<(), ()>> = PhantomData;
         WorkerBuilder {
             request: job,
             layer: ServiceBuilder::new(),
@@ -53,13 +53,17 @@ impl<Serv> WorkerBuilder<(), (), Identity, Serv> {
     }
 }
 
-impl<J, M, Serv> WorkerBuilder<J, (), M, Serv> {
+impl<M, Serv> WorkerBuilder<(), (), (), M, Serv> {
     /// Consume a stream directly
     #[deprecated(since = "0.6.0", note = "Consider using the `.backend`")]
-    pub fn stream<NS: Stream<Item = Result<Option<Request<NJ>>, Error>> + Send + 'static, NJ>(
+    pub fn stream<
+        NS: Stream<Item = Result<Option<Request<NJ, Ctx>>, Error>> + Send + 'static,
+        NJ,
+        Ctx,
+    >(
         self,
         stream: NS,
-    ) -> WorkerBuilder<NJ, NS, M, Serv> {
+    ) -> WorkerBuilder<NJ, Ctx, NS, M, Serv> {
         WorkerBuilder {
             request: PhantomData,
             layer: self.layer,
@@ -70,12 +74,12 @@ impl<J, M, Serv> WorkerBuilder<J, (), M, Serv> {
     }
 
     /// Set the source to a backend that implements [Backend]
-    pub fn backend<NB: Backend<Request<NJ>, Res>, NJ, Res: Send>(
+    pub fn backend<NB: Backend<Request<NJ, Ctx>, Res>, NJ, Res: Send, Ctx>(
         self,
         backend: NB,
-    ) -> WorkerBuilder<NJ, NB, M, Serv>
+    ) -> WorkerBuilder<NJ, Ctx, NB, M, Serv>
     where
-        Serv: Service<Request<NJ>, Response = Res>,
+        Serv: Service<Request<NJ, Ctx>, Response = Res>,
     {
         WorkerBuilder {
             request: PhantomData,
@@ -87,13 +91,13 @@ impl<J, M, Serv> WorkerBuilder<J, (), M, Serv> {
     }
 }
 
-impl<Request, Stream, M, Serv> WorkerBuilder<Request, Stream, M, Serv> {
+impl<Req, M, Serv, Ctx> WorkerBuilder<Req, Ctx, (), M, Serv> {
     /// Allows of decorating the service that consumes jobs.
     /// Allows adding multiple [`tower`] middleware
     pub fn chain<NewLayer>(
         self,
         f: impl Fn(ServiceBuilder<M>) -> ServiceBuilder<NewLayer>,
-    ) -> WorkerBuilder<Request, Stream, NewLayer, Serv> {
+    ) -> WorkerBuilder<Req, Ctx, (), NewLayer, Serv> {
         let middleware = f(self.layer);
 
         WorkerBuilder {
@@ -105,7 +109,7 @@ impl<Request, Stream, M, Serv> WorkerBuilder<Request, Stream, M, Serv> {
         }
     }
     /// Allows adding a single layer [tower] middleware
-    pub fn layer<U>(self, layer: U) -> WorkerBuilder<Request, Stream, Stack<U, M>, Serv>
+    pub fn layer<U>(self, layer: U) -> WorkerBuilder<Req, Ctx, (), Stack<U, M>, Serv>
     where
         M: Layer<U>,
     {
@@ -120,7 +124,7 @@ impl<Request, Stream, M, Serv> WorkerBuilder<Request, Stream, M, Serv> {
 
     /// Adds data to the context
     /// This will be shared by all requests
-    pub fn data<D>(self, data: D) -> WorkerBuilder<Request, Stream, Stack<Data<D>, M>, Serv>
+    pub fn data<D>(self, data: D) -> WorkerBuilder<Req, Ctx, (), Stack<Data<D>, M>, Serv>
     where
         M: Layer<Data<D>>,
     {
@@ -134,23 +138,22 @@ impl<Request, Stream, M, Serv> WorkerBuilder<Request, Stream, M, Serv> {
     }
 }
 
-impl<
-        Req: Send + 'static + Sync,
-        P: Backend<Request<Req>, S::Response> + 'static,
-        M: 'static,
-        S,
-    > WorkerFactory<Req, S> for WorkerBuilder<Req, P, M, S>
+impl<Req, P, M, S, Ctx> WorkerFactory<Req, Ctx, S> for WorkerBuilder<Req, Ctx, P, M, S>
 where
-    S: Service<Request<Req>> + Send + 'static + Clone + Sync,
+    S: Service<Request<Req, Ctx>> + Send + 'static + Sync,
     S::Future: Send,
 
     S::Response: 'static,
     M: Layer<S>,
+    Req: Send + 'static + Sync,
+    P: Backend<Request<Req, Ctx>, S::Response> + 'static,
+    M: 'static,
 {
     type Source = P;
 
     type Service = M::Service;
-    fn build(self, service: S) -> Worker<Ready<Self::Service, P>> {
+
+    fn build(self, service: S) -> Worker<Ready<M::Service, P>> {
         let worker_id = self.id;
         let poller = self.source;
         let middleware = self.layer;
@@ -159,9 +162,8 @@ where
         Worker::new(worker_id, Ready::new(service, poller))
     }
 }
-
 /// Helper trait for building new Workers from [`WorkerBuilder`]
-pub trait WorkerFactory<J, S> {
+pub trait WorkerFactory<Req, Ctx, S> {
     /// The request source for the worker
     type Source;
 
@@ -180,7 +182,7 @@ pub trait WorkerFactory<J, S> {
 
 /// Helper trait for building new Workers from [`WorkerBuilder`]
 
-pub trait WorkerFactoryFn<J, F, K> {
+pub trait WorkerFactoryFn<Req, Ctx, F, FnArgs> {
     /// The request source for the [`Worker`]
     type Source;
 
@@ -219,9 +221,9 @@ pub trait WorkerFactoryFn<J, F, K> {
     fn build_fn(self, f: F) -> Worker<Ready<Self::Service, Self::Source>>;
 }
 
-impl<J, W, F, K> WorkerFactoryFn<J, F, K> for W
+impl<Req, W, F, Ctx, FnArgs> WorkerFactoryFn<Req, Ctx, F, FnArgs> for W
 where
-    W: WorkerFactory<J, ServiceFn<F, K>>,
+    W: WorkerFactory<Req, Ctx, ServiceFn<F, Req, Ctx, FnArgs>>,
 {
     type Source = W::Source;
 
diff --git a/packages/apalis-core/src/data.rs b/packages/apalis-core/src/data.rs
index 33cd3f9..e2829c8 100644
--- a/packages/apalis-core/src/data.rs
+++ b/packages/apalis-core/src/data.rs
@@ -5,6 +5,8 @@ use std::collections::HashMap;
 use std::fmt;
 use std::hash::{BuildHasherDefault, Hasher};
 
+use crate::error::Error;
+
 type AnyMap = HashMap<TypeId, Box<dyn AnyClone + Send + Sync>, BuildHasherDefault<IdHasher>>;
 
 // With TypeIds as keys, there's no need to hash them. They are already hashes
@@ -87,6 +89,27 @@ impl Extensions {
             .and_then(|boxed| (**boxed).as_any().downcast_ref())
     }
 
+    /// Get a checked reference to a type previously inserted on this `Extensions`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use apalis_core::data::Extensions;
+    /// let mut ext = Extensions::new();
+    /// assert!(ext.get_checked::<i32>().is_err());
+    /// ext.insert(5i32);
+    ///
+    /// assert_eq!(ext.get_checked::<i32>(), Ok(&5i32));
+    /// ```
+    pub fn get_checked<T: Send + Sync + 'static>(&self) -> Result<&T, Error> {
+        self.get()
+            .ok_or({
+                let type_name = std::any::type_name::<T>();
+                Error::MissingData(
+                format!("Missing the an entry for `{type_name}`. Did you forget to add `.data(<{type_name}>)", ))
+            })
+    }
+
     /// Get a mutable reference to a type previously inserted on this `Extensions`.
     ///
     /// # Example
diff --git a/packages/apalis-core/src/error.rs b/packages/apalis-core/src/error.rs
index 64f1f66..aa27412 100644
--- a/packages/apalis-core/src/error.rs
+++ b/packages/apalis-core/src/error.rs
@@ -1,5 +1,13 @@
-use std::{error::Error as StdError, sync::Arc};
+use std::{
+    error::Error as StdError,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
 use thiserror::Error;
+use tower::Service;
 
 use crate::worker::WorkerError;
 
@@ -14,22 +22,21 @@ pub enum Error {
     #[error("FailedError: {0}")]
     Failed(#[source] Arc<BoxDynError>),
 
-    /// A generic IO error
-    #[error("IoError: {0}")]
-    Io(#[from] Arc<std::io::Error>),
-
-    /// Missing some context and yet it was requested during execution.
-    #[error("MissingContextError: {0}")]
-    MissingContext(String),
-
     /// Execution was aborted
     #[error("AbortError: {0}")]
     Abort(#[source] Arc<BoxDynError>),
 
+    #[doc(hidden)]
     /// Encountered an error during worker execution
+    /// This should not be used inside a task function
     #[error("WorkerError: {0}")]
     WorkerError(WorkerError),
 
+    /// Missing some data and yet it was requested during execution.
+    /// This should not be used inside a task function
+    #[error("MissingDataError: {0}")]
+    MissingData(String),
+
     #[doc(hidden)]
     /// Encountered an error during service execution
     /// This should not be used inside a task function
@@ -42,3 +49,83 @@ pub enum Error {
     #[error("Encountered an error during streaming")]
     SourceError(#[source] Arc<BoxDynError>),
 }
+
+impl From<BoxDynError> for Error {
+    fn from(err: BoxDynError) -> Self {
+        if let Some(e) = err.downcast_ref::<Error>() {
+            e.clone()
+        } else {
+            Error::Failed(Arc::new(err))
+        }
+    }
+}
+
+/// A Tower layer for handling and converting service errors into a custom `Error` type.
+///
+/// This layer wraps a service and intercepts any errors returned by the service.
+/// It attempts to downcast the error into the custom `Error` enum. If the downcast
+/// succeeds, it returns the downcasted `Error`. If the downcast fails, the original
+/// error is wrapped in `Error::Failed`.
+///
+/// The service's error type must implement `Into<BoxDynError>`, allowing for flexible
+/// error handling, especially when dealing with trait objects or complex error chains.
+#[derive(Clone, Debug)]
+pub struct ErrorHandlingLayer {
+    _p: PhantomData<()>,
+}
+
+impl ErrorHandlingLayer {
+    /// Create a new ErrorHandlingLayer
+    pub fn new() -> Self {
+        Self { _p: PhantomData }
+    }
+}
+
+impl Default for ErrorHandlingLayer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<S> tower::layer::Layer<S> for ErrorHandlingLayer {
+    type Service = ErrorHandlingService<S>;
+
+    fn layer(&self, service: S) -> Self::Service {
+        ErrorHandlingService { service }
+    }
+}
+
+/// The underlying service
+#[derive(Clone, Debug)]
+pub struct ErrorHandlingService<S> {
+    service: S,
+}
+
+impl<S, Request> Service<Request> for ErrorHandlingService<S>
+where
+    S: Service<Request>,
+    S::Error: Into<BoxDynError>,
+    S::Future: Send + 'static,
+{
+    type Response = S::Response;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx).map_err(|e| {
+            let boxed_error: BoxDynError = e.into();
+            boxed_error.into()
+        })
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        let fut = self.service.call(req);
+
+        Box::pin(async move {
+            fut.await.map_err(|e| {
+                let boxed_error: BoxDynError = e.into();
+                boxed_error.into()
+            })
+        })
+    }
+}
diff --git a/packages/apalis-core/src/layers.rs b/packages/apalis-core/src/layers.rs
index 891be4a..2d9c971 100644
--- a/packages/apalis-core/src/layers.rs
+++ b/packages/apalis-core/src/layers.rs
@@ -1,5 +1,6 @@
 use crate::error::{BoxDynError, Error};
 use crate::request::Request;
+use crate::response::Response;
 use futures::channel::mpsc::{SendError, Sender};
 use futures::SinkExt;
 use futures::{future::BoxFuture, Future, FutureExt};
@@ -133,9 +134,9 @@ pub mod extensions {
         value: T,
     }
 
-    impl<S, T, Req> Service<Request<Req>> for AddExtension<S, T>
+    impl<S, T, Req, Ctx> Service<Request<Req, Ctx>> for AddExtension<S, T>
     where
-        S: Service<Request<Req>>,
+        S: Service<Request<Req, Ctx>>,
         T: Clone + Send + Sync + 'static,
     {
         type Response = S::Response;
@@ -147,8 +148,8 @@ pub mod extensions {
             self.inner.poll_ready(cx)
         }
 
-        fn call(&mut self, mut req: Request<Req>) -> Self::Future {
-            req.data.insert(self.value.clone());
+        fn call(&mut self, mut req: Request<Req, Ctx>) -> Self::Future {
+            req.parts.data.insert(self.value.clone());
             self.inner.call(req)
         }
     }
@@ -157,7 +158,7 @@ pub mod extensions {
 /// A trait for acknowledging successful processing
 /// This trait is called even when a task fails.
 /// This is a way of a [`Backend`] to save the result of a job or message
-pub trait Ack<Task, Response> {
+pub trait Ack<Task, Res> {
     /// The data to fetch from context to allow acknowledgement
     type Context;
     /// The error returned by the ack
@@ -167,19 +168,19 @@ pub trait Ack<Task, Response> {
     fn ack(
         &mut self,
         ctx: &Self::Context,
-        result: &Result<Response, Error>,
+        response: &Response<Res>,
     ) -> impl Future<Output = Result<(), Self::AckError>> + Send;
 }
 
 impl<T, Res: Clone + Send + Sync, Ctx: Clone + Send + Sync> Ack<T, Res>
-    for Sender<(Ctx, Result<Res, Error>)>
+    for Sender<(Ctx, Response<Res>)>
 {
     type AckError = SendError;
     type Context = Ctx;
     async fn ack(
         &mut self,
         ctx: &Self::Context,
-        result: &Result<Res, Error>,
+        result: &Response<Res>,
     ) -> Result<(), Self::AckError> {
         let ctx = ctx.clone();
         self.send((ctx, result.clone())).await.unwrap();
@@ -189,13 +190,13 @@ impl<T, Res: Clone + Send + Sync, Ctx: Clone + Send + Sync> Ack<T, Res>
 
 /// A layer that acknowledges a job completed successfully
 #[derive(Debug)]
-pub struct AckLayer<A, J, Res> {
+pub struct AckLayer<A, Req, Ctx, Res> {
     ack: A,
-    job_type: PhantomData<J>,
+    job_type: PhantomData<Request<Req, Ctx>>,
     res: PhantomData<Res>,
 }
 
-impl<A, J, Res> AckLayer<A, J, Res> {
+impl<A, Req, Ctx, Res> AckLayer<A, Req, Ctx, Res> {
     /// Build a new [AckLayer] for a job
     pub fn new(ack: A) -> Self {
         Self {
@@ -206,14 +207,14 @@ impl<A, J, Res> AckLayer<A, J, Res> {
     }
 }
 
-impl<A, J, S, Res> Layer<S> for AckLayer<A, J, Res>
+impl<A, Req, Ctx, S, Res> Layer<S> for AckLayer<A, Req, Ctx, Res>
 where
-    S: Service<Request<J>> + Send + 'static,
+    S: Service<Request<Req, Ctx>> + Send + 'static,
     S::Error: std::error::Error + Send + Sync + 'static,
     S::Future: Send + 'static,
-    A: Ack<J, S::Response> + Clone + Send + Sync + 'static,
+    A: Ack<Req, S::Response> + Clone + Send + Sync + 'static,
 {
-    type Service = AckService<S, A, J, S::Response>;
+    type Service = AckService<S, A, Req, Ctx, S::Response>;
 
     fn layer(&self, service: S) -> Self::Service {
         AckService {
@@ -227,14 +228,14 @@ where
 
 /// The underlying service for an [AckLayer]
 #[derive(Debug)]
-pub struct AckService<SV, A, J, Res> {
+pub struct AckService<SV, A, Req, Ctx, Res> {
     service: SV,
     ack: A,
-    job_type: PhantomData<J>,
+    job_type: PhantomData<Request<Req, Ctx>>,
     res: PhantomData<Res>,
 }
 
-impl<Sv: Clone, A: Clone, J, Res> Clone for AckService<Sv, A, J, Res> {
+impl<Sv: Clone, A: Clone, Req, Ctx, Res> Clone for AckService<Sv, A, Req, Ctx, Res> {
     fn clone(&self) -> Self {
         Self {
             ack: self.ack.clone(),
@@ -245,15 +246,22 @@ impl<Sv: Clone, A: Clone, J, Res> Clone for AckService<Sv, A, J, Res> {
     }
 }
 
-impl<SV, A, T, Res> Service<Request<T>> for AckService<SV, A, T, Res>
+impl<SV, A, Req, Res, Ctx> Service<Request<Req, Ctx>> for AckService<SV, A, Req, Ctx, Res>
 where
-    SV: Service<Request<T>> + Send + Sync + 'static,
-    <SV as Service<Request<T>>>::Error: Into<BoxDynError> + Send + Sync + 'static,
-    <SV as Service<Request<T>>>::Future: std::marker::Send + 'static,
-    A: Ack<T, <SV as Service<Request<T>>>::Response> + Send + 'static + Clone + Send + Sync,
-    T: 'static + Send,
-    <SV as Service<Request<T>>>::Response: std::marker::Send + fmt::Debug + Sync + Serialize,
-    <A as Ack<T, SV::Response>>::Context: Sync + Send + Clone,
+    SV: Service<Request<Req, Ctx>> + Send + Sync + 'static,
+    <SV as Service<Request<Req, Ctx>>>::Error: Into<BoxDynError> + Send + Sync + 'static,
+    <SV as Service<Request<Req, Ctx>>>::Future: std::marker::Send + 'static,
+    A: Ack<Req, <SV as Service<Request<Req, Ctx>>>::Response, Context = Ctx>
+        + Send
+        + 'static
+        + Clone
+        + Send
+        + Sync,
+    Req: 'static + Send,
+    <SV as Service<Request<Req, Ctx>>>::Response: std::marker::Send + fmt::Debug + Sync + Serialize,
+    <A as Ack<Req, SV::Response>>::Context: Sync + Send + Clone,
+    <A as Ack<Req, <SV as Service<Request<Req, Ctx>>>::Response>>::Context: 'static,
+    Ctx: Clone,
 {
     type Response = SV::Response;
     type Error = Error;
@@ -268,12 +276,11 @@ where
             .map_err(|e| Error::Failed(Arc::new(e.into())))
     }
 
-    fn call(&mut self, request: Request<T>) -> Self::Future {
+    fn call(&mut self, request: Request<Req, Ctx>) -> Self::Future {
         let mut ack = self.ack.clone();
-        let data = request
-            .get::<<A as Ack<T, SV::Response>>::Context>()
-            .cloned();
-
+        let ctx = request.parts.context.clone();
+        let attempt = request.parts.attempt.clone();
+        let task_id = request.parts.task_id.clone();
         let fut = self.service.call(request);
         let fut_with_ack = async move {
             let res = fut.await.map_err(|err| {
@@ -284,19 +291,17 @@ where
                 }
                 Error::Failed(Arc::new(e))
             });
-
-            if let Some(ctx) = data {
-                if let Err(_e) = ack.ack(&ctx, &res).await {
-                    // TODO: Implement tracing in apalis core
-                    // tracing::error!("Acknowledgement Failed: {}", e);
-                }
-            } else {
-                // tracing::error!(
-                //     "Acknowledgement could not be called due to missing ack data in context : {}",
-                //     &std::any::type_name::<<A as Ack<T>>::Acknowledger>()
-                // );
+            let response = Response {
+                attempt,
+                inner: res,
+                task_id,
+                _priv: (),
+            };
+            if let Err(_e) = ack.ack(&ctx, &response).await {
+                // TODO: Implement tracing in apalis core
+                // tracing::error!("Acknowledgement Failed: {}", e);
             }
-            res
+            response.inner
         };
         fut_with_ack.boxed()
     }
diff --git a/packages/apalis-core/src/lib.rs b/packages/apalis-core/src/lib.rs
index 0e7157e..6f01618 100644
--- a/packages/apalis-core/src/lib.rs
+++ b/packages/apalis-core/src/lib.rs
@@ -251,28 +251,29 @@ pub mod test_utils {
     ///    }
     ///}
     /// ````
-    impl<B, Req, Res> TestWrapper<B, Req, Res>
+    impl<B, Req, Res, Ctx> TestWrapper<B, Request<Req, Ctx>, Res>
     where
-        B: Backend<Request<Req>, Res> + Send + Sync + 'static + Clone,
+        B: Backend<Request<Req, Ctx>, Res> + Send + Sync + 'static + Clone,
         Req: Send + 'static,
+        Ctx: Send,
         B::Stream: Send + 'static,
-        B::Stream: Stream<Item = Result<Option<Request<Req>>, crate::error::Error>> + Unpin,
+        B::Stream: Stream<Item = Result<Option<Request<Req, Ctx>>, crate::error::Error>> + Unpin,
     {
         /// Build a new instance provided a custom service
         pub fn new_with_service<S>(backend: B, service: S) -> (Self, BoxFuture<'static, ()>)
         where
-            S: Service<Request<Req>, Response = Res> + Send + 'static,
+            S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
             B::Layer: Layer<S>,
-            <<B as Backend<Request<Req>, Res>>::Layer as Layer<S>>::Service:
-                Service<Request<Req>> + Send + 'static,
-            <<<B as Backend<Request<Req>, Res>>::Layer as Layer<S>>::Service as Service<
-                Request<Req>,
+            <<B as Backend<Request<Req, Ctx>, Res>>::Layer as Layer<S>>::Service:
+                Service<Request<Req, Ctx>> + Send + 'static,
+            <<<B as Backend<Request<Req, Ctx>, Res>>::Layer as Layer<S>>::Service as Service<
+                Request<Req, Ctx>,
             >>::Response: Send + Debug,
-            <<<B as Backend<Request<Req>, Res>>::Layer as Layer<S>>::Service as Service<
-                Request<Req>,
+            <<<B as Backend<Request<Req, Ctx>, Res>>::Layer as Layer<S>>::Service as Service<
+                Request<Req, Ctx>,
             >>::Error: Send + Into<BoxDynError> + Sync,
-            <<<B as Backend<Request<Req>, Res>>::Layer as Layer<S>>::Service as Service<
-                Request<Req>,
+            <<<B as Backend<Request<Req, Ctx>, Res>>::Layer as Layer<S>>::Service as Service<
+                Request<Req, Ctx>,
             >>::Future: Send + 'static,
         {
             let worker_id = WorkerId::new("test-worker");
@@ -291,10 +292,7 @@ pub mod test_utils {
 
                         item = poller.stream.next().fuse() => match item {
                             Some(Ok(Some(req))) => {
-
-                                let task_id = req.get::<TaskId>().cloned().unwrap_or_default();
-                                // .expect("Request does not contain Task_ID");
-                                // handle request
+                                let task_id = req.parts.task_id.clone();
                                 match service.call(req).await {
                                     Ok(res) => {
                                         res_tx.send((task_id, Ok(format!("{res:?}")))).await.unwrap();
@@ -340,9 +338,9 @@ pub mod test_utils {
         }
     }
 
-    impl<B, Req, Res> Deref for TestWrapper<B, Req, Res>
+    impl<B, Req, Res, Ctx> Deref for TestWrapper<B, Request<Req, Ctx>, Res>
     where
-        B: Backend<Request<Req>, Res>,
+        B: Backend<Request<Req, Ctx>, Res>,
     {
         type Target = B;
 
@@ -351,9 +349,9 @@ pub mod test_utils {
         }
     }
 
-    impl<B, Req, Res> DerefMut for TestWrapper<B, Req, Res>
+    impl<B, Req, Ctx, Res> DerefMut for TestWrapper<B, Request<Req, Ctx>, Res>
     where
-        B: Backend<Request<Req>, Res>,
+        B: Backend<Request<Req, Ctx>, Res>,
     {
         fn deref_mut(&mut self) -> &mut Self::Target {
             &mut self.backend
@@ -369,7 +367,7 @@ pub mod test_utils {
             #[tokio::test]
             async fn it_works_as_an_mq_backend() {
                 let backend = $backend_instance;
-                let service = apalis_test_service_fn(|request: Request<u32>| async {
+                let service = apalis_test_service_fn(|request: Request<u32, ()>| async {
                     Ok::<_, io::Error>(request)
                 });
                 let (mut t, poller) = TestWrapper::new_with_service(backend, service);
@@ -388,8 +386,8 @@ pub mod test_utils {
             #[tokio::test]
             async fn integration_test_storage_push_and_consume() {
                 let backend = $setup().await;
-                let service = apalis_test_service_fn(|request: Request<u32>| async move {
-                    Ok::<_, io::Error>(request.take())
+                let service = apalis_test_service_fn(|request: Request<u32, _>| async move {
+                    Ok::<_, io::Error>(request.args)
                 });
                 let (mut t, poller) = TestWrapper::new_with_service(backend, service);
                 tokio::spawn(poller);
diff --git a/packages/apalis-core/src/memory.rs b/packages/apalis-core/src/memory.rs
index b8f08b4..731c450 100644
--- a/packages/apalis-core/src/memory.rs
+++ b/packages/apalis-core/src/memory.rs
@@ -52,8 +52,8 @@ impl<T> Clone for MemoryStorage<T> {
 /// In-memory queue that implements [Stream]
 #[derive(Debug)]
 pub struct MemoryWrapper<T> {
-    sender: Sender<Request<T>>,
-    receiver: Arc<futures::lock::Mutex<Receiver<Request<T>>>>,
+    sender: Sender<Request<T, ()>>,
+    receiver: Arc<futures::lock::Mutex<Receiver<Request<T, ()>>>>,
 }
 
 impl<T> Clone for MemoryWrapper<T> {
@@ -84,7 +84,7 @@ impl<T> Default for MemoryWrapper<T> {
 }
 
 impl<T> Stream for MemoryWrapper<T> {
-    type Item = Request<T>;
+    type Item = Request<T, ()>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         if let Some(mut receiver) = self.receiver.try_lock() {
@@ -96,8 +96,8 @@ impl<T> Stream for MemoryWrapper<T> {
 }
 
 // MemoryStorage as a Backend
-impl<T: Send + 'static + Sync, Res> Backend<Request<T>, Res> for MemoryStorage<T> {
-    type Stream = BackendStream<RequestStream<Request<T>>>;
+impl<T: Send + 'static + Sync, Res> Backend<Request<T, ()>, Res> for MemoryStorage<T> {
+    type Stream = BackendStream<RequestStream<Request<T, ()>>>;
 
     type Layer = Identity;
 
diff --git a/packages/apalis-core/src/monitor/mod.rs b/packages/apalis-core/src/monitor/mod.rs
index 82d19c4..92e0e45 100644
--- a/packages/apalis-core/src/monitor/mod.rs
+++ b/packages/apalis-core/src/monitor/mod.rs
@@ -79,27 +79,24 @@ impl<E> Debug for Monitor<E> {
 
 impl<E: Executor + Clone + Send + 'static + Sync> Monitor<E> {
     /// Registers a single instance of a [Worker]
-    pub fn register<
-        J: Send + Sync + 'static,
-        S: Service<Request<J>> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        Res: 'static
-    >(
-        mut self,
-        worker: Worker<Ready<S, P>>,
-    ) -> Self
+    pub fn register<Req, S, P, Res, Ctx>(mut self, worker: Worker<Ready<S, P>>) -> Self
     where
         S::Future: Send,
         S::Response: 'static + Send + Sync + Serialize,
         S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
+        P::Stream: Unpin + Send + 'static,
         P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Future:
-            Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Error:
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res>,
+        <P::Layer as Layer<S>>::Service: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
             Send + Into<BoxDynError> + Sync,
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        Ctx: Send + Sync + 'static,
+        Req: Send + Sync + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Res: 'static,
+        Ctx: Send + Sync + 'static,
     {
         self.workers.push(worker.with_monitor(&self));
 
@@ -116,12 +113,7 @@ impl<E: Executor + Clone + Send + 'static + Sync> Monitor<E> {
     /// # Returns
     ///
     /// The monitor instance, with all workers added to the collection.
-    pub fn register_with_count<
-        J: Send + Sync + 'static,
-        S: Service<Request<J>> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        Res: 'static + Send,
-    >(
+    pub fn register_with_count<Req, S, P, Res, Ctx>(
         mut self,
         count: usize,
         worker: Worker<Ready<S, P>>,
@@ -130,14 +122,21 @@ impl<E: Executor + Clone + Send + 'static + Sync> Monitor<E> {
         S::Future: Send,
         S::Response: 'static + Send + Sync + Serialize,
         S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
+        P::Stream: Unpin + Send + 'static,
         P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Future:
-            Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Error:
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res>,
+        <P::Layer as Layer<S>>::Service: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
             Send + Into<BoxDynError> + Sync,
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        Ctx: Send + Sync + 'static,
+        Req: Send + Sync + 'static,
+        S: Service<Request<Req, Ctx>> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Res: 'static,
+        Ctx: Send + Sync + 'static,
     {
         let workers = worker.with_monitor_instances(count, &self);
         self.workers.extend(workers);
@@ -328,7 +327,7 @@ mod tests {
                 handle.enqueue(i).await.unwrap();
             }
         });
-        let service = tower::service_fn(|request: Request<u32>| async {
+        let service = tower::service_fn(|request: Request<u32, ()>| async {
             tokio::time::sleep(Duration::from_secs(1)).await;
             Ok::<_, io::Error>(request)
         });
@@ -354,7 +353,7 @@ mod tests {
                 handle.enqueue(i).await.unwrap();
             }
         });
-        let service = tower::service_fn(|request: Request<u32>| async {
+        let service = tower::service_fn(|request: Request<u32, _>| async {
             tokio::time::sleep(Duration::from_secs(1)).await;
             Ok::<_, io::Error>(request)
         });
diff --git a/packages/apalis-core/src/request.rs b/packages/apalis-core/src/request.rs
index 11bea89..428b4a8 100644
--- a/packages/apalis-core/src/request.rs
+++ b/packages/apalis-core/src/request.rs
@@ -8,56 +8,93 @@ use crate::{
     data::Extensions,
     error::Error,
     poller::Poller,
-    task::{attempt::Attempt, task_id::TaskId},
+    task::{attempt::Attempt, namespace::Namespace, task_id::TaskId},
     worker::WorkerId,
     Backend,
 };
 
 /// Represents a job which can be serialized and executed
 
-#[derive(Serialize, Debug, Deserialize, Clone)]
-pub struct Request<T> {
-    pub(crate) args: T,
+#[derive(Serialize, Debug, Deserialize, Clone, Default)]
+pub struct Request<Args, Ctx> {
+    /// The inner request part
+    pub args: Args,
+    /// Parts of the request eg id, attempts and context
+    pub parts: Parts<Ctx>,
+}
+
+/// Component parts of a `Request`
+#[non_exhaustive]
+#[derive(Serialize, Debug, Deserialize, Clone, Default)]
+pub struct Parts<Ctx> {
+    /// The request's id
+    pub task_id: TaskId,
+
+    /// The request's extensions
     #[serde(skip)]
-    pub(crate) data: Extensions,
+    pub data: Extensions,
+
+    /// The request's attempts
+    pub attempt: Attempt,
+
+    /// The Context stored by the storage
+    pub context: Ctx,
+
+    /// Represents the namespace
+    #[serde(skip)]
+    pub namespace: Option<Namespace>,
 }
 
-impl<T> Request<T> {
+impl<T, Ctx: Default> Request<T, Ctx> {
     /// Creates a new [Request]
-    pub fn new(req: T) -> Self {
-        let id = TaskId::new();
-        let mut data = Extensions::new();
-        data.insert(id);
-        data.insert(Attempt::default());
-        Self::new_with_data(req, data)
+    pub fn new(args: T) -> Self {
+        Self::new_with_data(args, Extensions::default(), Ctx::default())
+    }
+
+    /// Creates a request with all parts provided
+    pub fn new_with_parts(args: T, parts: Parts<Ctx>) -> Self {
+        Self { args, parts }
     }
 
     /// Creates a request with context provided
-    pub fn new_with_data(req: T, data: Extensions) -> Self {
-        Self { args: req, data }
+    pub fn new_with_ctx(req: T, ctx: Ctx) -> Self {
+        Self {
+            args: req,
+            parts: Parts {
+                context: ctx,
+                ..Default::default()
+            },
+        }
     }
 
-    /// Get the underlying reference of the request
-    pub fn inner(&self) -> &T {
-        &self.args
+    /// Creates a request with data and context provided
+    pub fn new_with_data(req: T, data: Extensions, ctx: Ctx) -> Self {
+        Self {
+            args: req,
+            parts: Parts {
+                context: ctx,
+                data,
+                ..Default::default()
+            },
+        }
     }
 
-    /// Take the underlying reference of the request
-    pub fn take(self) -> T {
-        self.args
+    /// Take the parts
+    pub fn take_parts(self) -> (T, Parts<Ctx>) {
+        (self.args, self.parts)
     }
 }
 
-impl<T> std::ops::Deref for Request<T> {
+impl<T, Ctx> std::ops::Deref for Request<T, Ctx> {
     type Target = Extensions;
     fn deref(&self) -> &Self::Target {
-        &self.data
+        &self.parts.data
     }
 }
 
-impl<T> std::ops::DerefMut for Request<T> {
+impl<T, Ctx> std::ops::DerefMut for Request<T, Ctx> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.data
+        &mut self.parts.data
     }
 }
 
@@ -69,7 +106,7 @@ pub type RequestFuture<T> = BoxFuture<'static, T>;
 /// Represents a stream for T.
 pub type RequestStream<T> = BoxStream<'static, Result<Option<T>, Error>>;
 
-impl<T, Res> Backend<Request<T>, Res> for RequestStream<Request<T>> {
+impl<T, Res, Ctx> Backend<Request<T, Ctx>, Res> for RequestStream<Request<T, Ctx>> {
     type Stream = Self;
 
     type Layer = Identity;
diff --git a/packages/apalis-core/src/response.rs b/packages/apalis-core/src/response.rs
index efda892..eb917be 100644
--- a/packages/apalis-core/src/response.rs
+++ b/packages/apalis-core/src/response.rs
@@ -1,6 +1,116 @@
-use std::{any::Any, sync::Arc};
+use std::{any::Any, fmt::Debug, sync::Arc};
 
-use crate::error::Error;
+use crate::{
+    error::Error,
+    task::{attempt::Attempt, task_id::TaskId},
+};
+
+/// A generic `Response` struct that wraps the result of a task, containing the outcome (`Ok` or `Err`),
+/// task metadata such as `task_id`, `attempt`, and an internal marker field for future extensions.
+///
+/// # Type Parameters
+/// - `Res`: The successful result type of the response.
+///
+/// # Fields
+/// - `inner`: A `Result` that holds either the success value of type `Res` or an `Error` on failure.
+/// - `task_id`: A `TaskId` representing the unique identifier for the task.
+/// - `attempt`: An `Attempt` representing how many attempts were made to complete the task.
+/// - `_priv`: A private marker field to prevent external construction of the `Response`.
+#[derive(Debug, Clone)]
+pub struct Response<Res> {
+    /// The result from a task
+    pub inner: Result<Res, Error>,
+    /// The task id
+    pub task_id: TaskId,
+    /// The current attempt
+    pub attempt: Attempt,
+    pub(crate) _priv: (),
+}
+
+impl<Res> Response<Res> {
+    /// Creates a new `Response` instance.
+    ///
+    /// # Arguments
+    /// - `inner`: A `Result` holding either a successful response of type `Res` or an `Error`.
+    /// - `task_id`: A `TaskId` representing the unique identifier for the task.
+    /// - `attempt`: The attempt count when creating this response.
+    ///
+    /// # Returns
+    /// A new `Response` instance.
+    pub fn new(inner: Result<Res, Error>, task_id: TaskId, attempt: Attempt) -> Self {
+        Response {
+            inner,
+            task_id,
+            attempt,
+            _priv: (),
+        }
+    }
+
+    /// Constructs a successful `Response`.
+    ///
+    /// # Arguments
+    /// - `res`: The success value of type `Res`.
+    /// - `task_id`: A `TaskId` representing the unique identifier for the task.
+    /// - `attempt`: The attempt count when creating this response.
+    ///
+    /// # Returns
+    /// A `Response` instance containing the success value.
+    pub fn success(res: Res, task_id: TaskId, attempt: Attempt) -> Self {
+        Self::new(Ok(res), task_id, attempt)
+    }
+
+    /// Constructs a failed `Response`.
+    ///
+    /// # Arguments
+    /// - `error`: The `Error` that occurred.
+    /// - `task_id`: A `TaskId` representing the unique identifier for the task.
+    /// - `attempt`: The attempt count when creating this response.
+    ///
+    /// # Returns
+    /// A `Response` instance containing the error.
+    pub fn failure(error: Error, task_id: TaskId, attempt: Attempt) -> Self {
+        Self::new(Err(error), task_id, attempt)
+    }
+
+    /// Checks if the `Response` contains a success (`Ok`).
+    ///
+    /// # Returns
+    /// `true` if the `Response` is successful, `false` otherwise.
+    pub fn is_success(&self) -> bool {
+        self.inner.is_ok()
+    }
+
+    /// Checks if the `Response` contains a failure (`Err`).
+    ///
+    /// # Returns
+    /// `true` if the `Response` is a failure, `false` otherwise.
+    pub fn is_failure(&self) -> bool {
+        self.inner.is_err()
+    }
+
+    /// Maps the success value (`Res`) of the `Response` to another type using the provided function.
+    ///
+    /// # Arguments
+    /// - `f`: A function that takes a reference to the success value and returns a new value of type `T`.
+    ///
+    /// # Returns
+    /// A new `Response` with the transformed success value or the same error.
+    ///
+    /// # Type Parameters
+    /// - `F`: A function or closure that takes a reference to a value of type `Res` and returns a value of type `T`.
+    /// - `T`: The new type of the success value after mapping.
+    pub fn map<F, T>(&self, f: F) -> Response<T>
+    where
+        F: FnOnce(&Res) -> T,
+    {
+        Response {
+            inner: self.inner.as_ref().map(f).map_err(|e| e.clone()),
+            task_id: self.task_id.clone(),
+            attempt: self.attempt.clone(),
+            _priv: (),
+        }
+    }
+}
 
 /// Helper for Job Responses
 pub trait IntoResponse {
diff --git a/packages/apalis-core/src/service_fn.rs b/packages/apalis-core/src/service_fn.rs
index d89e4df..85ef4e3 100644
--- a/packages/apalis-core/src/service_fn.rs
+++ b/packages/apalis-core/src/service_fn.rs
@@ -1,3 +1,4 @@
+use crate::error::Error;
 use crate::layers::extensions::Data;
 use crate::request::Request;
 use crate::response::IntoResponse;
@@ -10,20 +11,25 @@ use std::task::{Context, Poll};
 use tower::Service;
 
 /// A helper method to build functions
-pub fn service_fn<T, K>(f: T) -> ServiceFn<T, K> {
-    ServiceFn { f, k: PhantomData }
+pub fn service_fn<T, Req, Ctx, FnArgs>(f: T) -> ServiceFn<T, Req, Ctx, FnArgs> {
+    ServiceFn {
+        f,
+        req: PhantomData,
+        fn_args: PhantomData,
+    }
 }
 
 /// An executable service implemented by a closure.
 ///
 /// See [`service_fn`] for more details.
 #[derive(Copy, Clone)]
-pub struct ServiceFn<T, K> {
+pub struct ServiceFn<T, Req, Ctx, FnArgs> {
     f: T,
-    k: PhantomData<K>,
+    req: PhantomData<Request<Req, Ctx>>,
+    fn_args: PhantomData<FnArgs>,
 }
 
-impl<T, K> fmt::Debug for ServiceFn<T, K> {
+impl<T, Req, Ctx, FnArgs> fmt::Debug for ServiceFn<T, Req, Ctx, FnArgs> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ServiceFn")
             .field("f", &format_args!("{}", std::any::type_name::<T>()))
@@ -34,48 +40,62 @@ impl<T, K> fmt::Debug for ServiceFn<T, K> {
 /// The Future returned from [`ServiceFn`] service.
 pub type FnFuture<F, O, R, E> = Map<F, fn(O) -> std::result::Result<R, E>>;
 
-/// Allows getting some type from the [Request] data
-pub trait FromData: Sized + Clone + Send + Sync + 'static {
-    /// Gets the value
-    fn get(data: &crate::data::Extensions) -> Self {
-        data.get::<Self>().unwrap().clone()
-    }
+/// Handles extraction
+pub trait FromRequest<Req>: Sized {
+    /// Perform the extraction.
+    fn from_request(req: &Req) -> Result<Self, Error>;
 }
 
-impl<T: Clone + Send + Sync + 'static> FromData for Data<T> {
-    fn get(ctx: &crate::data::Extensions) -> Self {
-        Data::new(ctx.get::<T>().unwrap().clone())
+impl<T: Clone + Send + Sync + 'static, Req, Ctx> FromRequest<Request<Req, Ctx>> for Data<T> {
+    fn from_request(req: &Request<Req, Ctx>) -> Result<Self, Error> {
+        req.parts.data.get_checked().cloned().map(Data::new)
     }
 }
 
 macro_rules! impl_service_fn {
     ($($K:ident),+) => {
         #[allow(unused_parens)]
-        impl<T, F, Req, E, R, $($K),+> Service<Request<Req>> for ServiceFn<T, ($($K),+)>
+        impl<T, F, Req, E, R, Ctx, $($K),+> Service<Request<Req, Ctx>> for ServiceFn<T, Req, Ctx, ($($K),+)>
         where
             T: FnMut(Req, $($K),+) -> F,
             F: Future,
             F::Output: IntoResponse<Result = std::result::Result<R, E>>,
-            $($K: FromData),+,
+            $($K: FromRequest<Request<Req, Ctx>>),+,
+            E: From<Error>
         {
             type Response = R;
             type Error = E;
-            type Future = FnFuture<F, F::Output, R, E>;
+            type Future = futures::future::Either<futures::future::Ready<Result<R, E>>, FnFuture<F, F::Output, R, E>>;
 
             fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
                 Poll::Ready(Ok(()))
             }
 
-            fn call(&mut self, task: Request<Req>) -> Self::Future {
-                let fut = (self.f)(task.args, $($K::get(&task.data)),+);
+            fn call(&mut self, task: Request<Req, Ctx>) -> Self::Future {
+
+                #[allow(non_snake_case)]
+                let fut = {
+                    let results: Result<($($K),+), E> = (|| {
+                        Ok(($($K::from_request(&task)?),+))
+                    })();
+
+                    match results {
+                        Ok(($($K),+)) => {
+                            let req = task.args;
+                            (self.f)(req, $($K),+)
+                        }
+                        Err(e) => return futures::future::Either::Left(futures::future::err(e).into()),
+                    }
+                };
+
 
-                fut.map(F::Output::into_response)
+                futures::future::Either::Right(fut.map(F::Output::into_response))
             }
         }
     };
 }
 
-impl<T, F, Req, E, R> Service<Request<Req>> for ServiceFn<T, ()>
+impl<T, F, Req, E, R, Ctx> Service<Request<Req, Ctx>> for ServiceFn<T, Req, Ctx, ()>
 where
     T: FnMut(Req) -> F,
     F: Future,
@@ -89,7 +109,7 @@ where
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, task: Request<Req>) -> Self::Future {
+    fn call(&mut self, task: Request<Req, Ctx>) -> Self::Future {
         let fut = (self.f)(task.args);
 
         fut.map(F::Output::into_response)
diff --git a/packages/apalis-core/src/storage/mod.rs b/packages/apalis-core/src/storage/mod.rs
index f3b26fe..c761c74 100644
--- a/packages/apalis-core/src/storage/mod.rs
+++ b/packages/apalis-core/src/storage/mod.rs
@@ -1,11 +1,11 @@
 use std::time::Duration;
 
-use futures::{stream::BoxStream, Future};
+use futures::Future;
 
-use crate::request::Request;
-
-/// The result of sa stream produced by a [Storage]
-pub type StorageStream<T, E> = BoxStream<'static, Result<Option<Request<T>>, E>>;
+use crate::{
+    request::{Parts, Request},
+    task::task_id::TaskId,
+};
 
 /// Represents a [Storage] that can persist a request.
 pub trait Storage {
@@ -15,21 +15,38 @@ pub trait Storage {
     /// The error produced by the storage
     type Error;
 
-    /// Jobs must have Ids.
-    type Identifier;
+    /// This is the type that storages store as the metadata related to a job
+    type Context: Default;
 
     /// Pushes a job to a storage
     fn push(
         &mut self,
         job: Self::Job,
-    ) -> impl Future<Output = Result<Self::Identifier, Self::Error>> + Send;
+    ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send {
+        self.push_request(Request::new(job))
+    }
+
+    /// Pushes a constructed request to a storage
+    fn push_request(
+        &mut self,
+        req: Request<Self::Job, Self::Context>,
+    ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send;
 
-    /// Push a job into the scheduled set
+    /// Push a job with defaults into the scheduled set
     fn schedule(
         &mut self,
         job: Self::Job,
         on: i64,
-    ) -> impl Future<Output = Result<Self::Identifier, Self::Error>> + Send;
+    ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send {
+        self.schedule_request(Request::new(job), on)
+    }
+
+    /// Push a request into the scheduled set
+    fn schedule_request(
+        &mut self,
+        request: Request<Self::Job, Self::Context>,
+        on: i64,
+    ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send;
 
     /// Return the number of pending jobs from the queue
     fn len(&mut self) -> impl Future<Output = Result<i64, Self::Error>> + Send;
@@ -37,19 +54,19 @@ pub trait Storage {
     /// Fetch a job given an id
     fn fetch_by_id(
         &mut self,
-        job_id: &Self::Identifier,
-    ) -> impl Future<Output = Result<Option<Request<Self::Job>>, Self::Error>> + Send;
+        job_id: &TaskId,
+    ) -> impl Future<Output = Result<Option<Request<Self::Job, Self::Context>>, Self::Error>> + Send;
 
     /// Update a job details
     fn update(
         &mut self,
-        job: Request<Self::Job>,
+        job: Request<Self::Job, Self::Context>,
     ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 
     /// Reschedule a job
     fn reschedule(
         &mut self,
-        job: Request<Self::Job>,
+        job: Request<Self::Job, Self::Context>,
         wait: Duration,
     ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 
diff --git a/packages/apalis-core/src/task/attempt.rs b/packages/apalis-core/src/task/attempt.rs
index 3f4825a..9c1d84e 100644
--- a/packages/apalis-core/src/task/attempt.rs
+++ b/packages/apalis-core/src/task/attempt.rs
@@ -5,6 +5,8 @@ use std::sync::{
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use crate::{request::Request, service_fn::FromRequest};
+
 /// A wrapper to keep count of the attempts tried by a task
 #[derive(Debug, Clone)]
 pub struct Attempt(Arc<AtomicUsize>);
@@ -72,3 +74,9 @@ impl Attempt {
         self.0.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
     }
 }
+
+impl<Req, Ctx> FromRequest<Request<Req, Ctx>> for Attempt {
+    fn from_request(req: &Request<Req, Ctx>) -> Result<Self, crate::error::Error> {
+        Ok(req.parts.attempt.clone())
+    }
+}
diff --git a/packages/apalis-core/src/task/namespace.rs b/packages/apalis-core/src/task/namespace.rs
index c38f60b..16a5c9d 100644
--- a/packages/apalis-core/src/task/namespace.rs
+++ b/packages/apalis-core/src/task/namespace.rs
@@ -2,8 +2,10 @@ use std::convert::From;
 use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 
+use serde::{Deserialize, Serialize};
+
 /// A wrapper type that defines a task's namespace.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Namespace(pub String);
 
 impl Deref for Namespace {
diff --git a/packages/apalis-core/src/worker/mod.rs b/packages/apalis-core/src/worker/mod.rs
index a4c1f95..e5cf5c6 100644
--- a/packages/apalis-core/src/worker/mod.rs
+++ b/packages/apalis-core/src/worker/mod.rs
@@ -6,7 +6,7 @@ use crate::monitor::{Monitor, MonitorContext};
 use crate::notify::Notify;
 use crate::poller::FetchNext;
 use crate::request::Request;
-use crate::service_fn::FromData;
+use crate::service_fn::FromRequest;
 use crate::Backend;
 use futures::future::Shared;
 use futures::{Future, FutureExt};
@@ -77,8 +77,6 @@ impl FromStr for WorkerId {
     }
 }
 
-impl FromData for WorkerId {}
-
 impl Display for WorkerId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(self.name())?;
@@ -218,222 +216,76 @@ impl<E: Executor + Clone + Send + 'static> Worker<Context<E>> {
 }
 
 impl<S, P> Worker<Ready<S, P>> {
-    /// Start a worker with a custom executor
-    pub fn with_executor<E, J, Res: 'static>(self, executor: E) -> Worker<Context<E>>
-    where
-        S: Service<Request<J>> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        J: Send + 'static + Sync,
-        S::Future: Send,
-        S::Response: 'static + Send + Sync + Serialize,
-        S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
-        E: Executor + Clone + Send + 'static + Sync,
-        P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res> + 'static,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Future:
-            Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<Request<J>>>::Error:
-            Send + std::error::Error + Sync,
-    {
-        let notifier = Notify::new();
-        let service = self.state.service;
-        let backend = self.state.backend;
-        let poller = backend
-            .poll::<<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service>(self.id.clone());
-        let polling = poller.heartbeat.shared();
-        let default_layer = poller.layer;
-        let service = default_layer.layer(service);
-        let worker_stream = WorkerStream::new(poller.stream, notifier.clone())
-            .into_future()
-            .shared();
-        Self::build_worker_instance(
-            WorkerId::new(self.id.name()),
-            service,
-            executor.clone(),
-            notifier.clone(),
-            polling.clone(),
-            worker_stream.clone(),
-            None,
-        )
-    }
-
-    /// Run as a monitored worker
-    pub fn with_monitor<E, J, Res: 'static>(self, monitor: &Monitor<E>) -> Worker<Context<E>>
-    where
-        S: Service<Request<J>> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        J: Send + 'static + Sync,
-        S::Future: Send,
-        S::Response: 'static + Send + Sync + Serialize,
-        S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
-        E: Executor + Clone + Send + 'static + Sync,
-        P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Future: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Error: Send + Into<BoxDynError> + Sync,
-    {
-        let notifier = Notify::new();
-        let service = self.state.service;
-        let backend = self.state.backend;
-        let executor = monitor.executor().clone();
-        let context = monitor.context().clone();
-        let poller = backend
-            .poll::<<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service>(self.id.clone());
-        let default_layer = poller.layer;
-        let service = default_layer.layer(service);
-        let polling = poller.heartbeat.shared();
-        let worker_stream = WorkerStream::new(poller.stream, notifier.clone())
-            .into_future()
-            .shared();
-        Self::build_worker_instance(
-            WorkerId::new(self.id.name()),
-            service,
-            executor.clone(),
-            notifier.clone(),
-            polling.clone(),
-            worker_stream.clone(),
-            Some(context.clone()),
-        )
-    }
-
-    /// Run a specified amounts of instances
-    pub fn with_monitor_instances<E, J, Res: 'static + Send>(
+    fn common_worker_setup<E, Req, Res: 'static, Ctx>(
         self,
+        executor: E,
+        context: Option<MonitorContext>,
         instances: usize,
-        monitor: &Monitor<E>,
     ) -> Vec<Worker<Context<E>>>
     where
-        S: Service<Request<J>> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        J: Send + 'static + Sync,
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Req: Send + 'static + Sync,
         S::Future: Send,
         S::Response: 'static + Send + Sync + Serialize,
         S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
+        P::Stream: Unpin + Send + 'static,
         E: Executor + Clone + Send + 'static + Sync,
         P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Future: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Error: Send + Into<BoxDynError> + Sync,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
+            Send + Into<BoxDynError> + Sync,
+        Ctx: Send + 'static + Sync,
     {
         let notifier = Notify::new();
         let service = self.state.service;
-        let backend = self.state.backend;
-        let executor = monitor.executor().clone();
-        let context = monitor.context().clone();
-        let poller = backend
-            .poll::<<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service>(self.id.clone());
-        let default_layer = poller.layer;
-        let service = default_layer.layer(service);
-        let (service, poll_worker) = Buffer::pair(service, instances);
-        let polling = poller.heartbeat.shared();
-        let worker_stream = WorkerStream::new(poller.stream, notifier.clone())
-            .into_future()
-            .shared();
-        let mut workers = Vec::new();
-
-        executor.spawn(poll_worker);
-
-        for instance in 0..instances {
-            workers.push(Self::build_worker_instance(
-                WorkerId::new_with_instance(self.id.name(), instance),
-                service.clone(),
-                executor.clone(),
-                notifier.clone(),
-                polling.clone(),
-                worker_stream.clone(),
-                Some(context.clone()),
-            ));
-        }
-
-        workers
-    }
 
-    /// Run specified worker instances via a specific executor
-    pub fn with_executor_instances<E, J, Res: 'static>(
-        self,
-        instances: usize,
-        executor: E,
-    ) -> Vec<Worker<Context<E>>>
-    where
-        S: Service<Request<J>, Response = Res> + Send + 'static,
-        P: Backend<Request<J>, Res> + 'static,
-        J: Send + 'static + Sync,
-        S::Future: Send,
-        S::Response: 'static + Send + Sync + Serialize,
-        S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        S::Error: Send + Sync + 'static + Into<BoxDynError>,
-        <P as Backend<Request<J>, Res>>::Stream: Unpin + Send + 'static,
-        E: Executor + Clone + Send + 'static + Sync,
-        P::Layer: Layer<S>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Service<Request<J>, Response = Res>,
-        <<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Future: Send,
-        <<<P as Backend<Request<J>, Res>>::Layer as Layer<S>>::Service as Service<
-            Request<J>,
-        >>::Error: Send + Into<BoxDynError> + Sync,
-    {
-        let worker_id = self.id.clone();
-        let notifier = Notify::new();
-        let service = self.state.service;
         let (service, poll_worker) = Buffer::pair(service, instances);
         let backend = self.state.backend;
-        let poller = backend.poll::<S>(worker_id.clone());
+        let poller = backend.poll::<S>(self.id.clone());
         let polling = poller.heartbeat.shared();
         let worker_stream = WorkerStream::new(poller.stream, notifier.clone())
             .into_future()
             .shared();
+
         executor.spawn(poll_worker);
-        let mut workers = Vec::new();
-        for instance in 0..instances {
-            workers.push(Self::build_worker_instance(
-                WorkerId::new_with_instance(self.id.name(), instance),
-                service.clone(),
-                executor.clone(),
-                notifier.clone(),
-                polling.clone(),
-                worker_stream.clone(),
-                None,
-            ));
-        }
-        workers
-    }
 
-    pub(crate) fn build_worker_instance<LS, J, E, Res>(
+        (0..instances)
+            .map(|instance| {
+                Self::build_worker_instance(
+                    WorkerId::new_with_instance(self.id.name(), instance),
+                    service.clone(),
+                    executor.clone(),
+                    notifier.clone(),
+                    polling.clone(),
+                    worker_stream.clone(),
+                    context.clone(),
+                )
+            })
+            .collect()
+    }
+
+    fn build_worker_instance<LS, Req, E, Res, Ctx>(
         id: WorkerId,
         service: LS,
         executor: E,
-        notifier: WorkerNotify<Result<Option<Request<J>>, Error>>,
+        notifier: WorkerNotify<Result<Option<Request<Req, Ctx>>, Error>>,
         polling: Shared<impl Future<Output = ()> + Send + 'static>,
         worker_stream: Shared<impl Future<Output = ()> + Send + 'static>,
         context: Option<MonitorContext>,
     ) -> Worker<Context<E>>
     where
-        LS: Service<Request<J>, Response = Res> + Send + 'static,
+        LS: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
         LS::Future: Send + 'static,
-        LS::Response: 'static,
+        LS::Response: 'static + Send + Sync + Serialize,
         LS::Error: Send + Sync + Into<BoxDynError> + 'static,
-        P: Backend<Request<J>, Res>,
+        P: Backend<Request<Req, Ctx>, Res>,
         E: Executor + Send + Clone + 'static + Sync,
-        J: Sync + Send + 'static,
+        Req: Sync + Send + 'static,
         S: 'static,
         P: 'static,
+        Ctx: Send + 'static + Sync,
     {
         let instance = id.instance.unwrap_or_default();
         let ctx = Context {
@@ -454,17 +306,119 @@ impl<S, P> Worker<Ready<S, P>> {
         worker
     }
 
-    pub(crate) async fn build_instance<LS, J, E, Res>(
+    /// Setup a worker with an executor
+    pub fn with_executor<E, Req, Res: 'static, Ctx>(self, executor: E) -> Worker<Context<E>>
+    where
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Req: Send + 'static + Sync,
+        S::Future: Send,
+        S::Response: 'static + Send + Sync + Serialize,
+        S::Error: Send + Sync + 'static + Into<BoxDynError>,
+        P::Stream: Unpin + Send + 'static,
+        E: Executor + Clone + Send + 'static + Sync,
+        P::Layer: Layer<S>,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
+            Send + Into<BoxDynError> + Sync,
+        Ctx: Send + Sync + 'static,
+    {
+        self.common_worker_setup(executor, None, 1).pop().unwrap()
+    }
+
+    /// Setup a worker with the monitor
+    pub fn with_monitor<E, Req, Res: 'static, Ctx>(self, monitor: &Monitor<E>) -> Worker<Context<E>>
+    where
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Req: Send + 'static + Sync,
+        S::Future: Send,
+        S::Response: 'static + Send + Sync + Serialize,
+        S::Error: Send + Sync + 'static + Into<BoxDynError>,
+        P::Stream: Unpin + Send + 'static,
+        E: Executor + Clone + Send + 'static + Sync,
+        P::Layer: Layer<S>,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
+            Send + Into<BoxDynError> + Sync,
+        Ctx: Send + Sync + 'static,
+    {
+        self.common_worker_setup(
+            monitor.executor().clone(),
+            Some(monitor.context().clone()),
+            1,
+        )
+        .pop()
+        .unwrap()
+    }
+
+    /// Setup instances of the worker with the Monitor
+    pub fn with_monitor_instances<E, Req, Res: 'static + Send, Ctx>(
+        self,
+        instances: usize,
+        monitor: &Monitor<E>,
+    ) -> Vec<Worker<Context<E>>>
+    where
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Req: Send + 'static + Sync,
+        S::Future: Send,
+        S::Response: 'static + Send + Sync + Serialize,
+        S::Error: Send + Sync + 'static + Into<BoxDynError>,
+        P::Stream: Unpin + Send + 'static,
+        E: Executor + Clone + Send + 'static + Sync,
+        P::Layer: Layer<S>,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
+            Send + Into<BoxDynError> + Sync,
+        Ctx: Send + Sync + 'static,
+    {
+        self.common_worker_setup(
+            monitor.executor().clone(),
+            Some(monitor.context().clone()),
+            instances,
+        )
+    }
+
+    /// Setup worker instances providing an executor
+    pub fn with_executor_instances<E, Req, Res: 'static, Ctx>(
+        self,
+        instances: usize,
+        executor: E,
+    ) -> Vec<Worker<Context<E>>>
+    where
+        S: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
+        P: Backend<Request<Req, Ctx>, Res> + 'static,
+        Req: Send + 'static + Sync,
+        S::Future: Send,
+        S::Response: 'static + Send + Sync + Serialize,
+        S::Error: Send + Sync + 'static + Into<BoxDynError>,
+        P::Stream: Unpin + Send + 'static,
+        E: Executor + Clone + Send + 'static + Sync,
+        P::Layer: Layer<S>,
+        <P::Layer as Layer<S>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Future: Send,
+        <<P::Layer as Layer<S>>::Service as Service<Request<Req, Ctx>>>::Error:
+            Send + Into<BoxDynError> + Sync,
+        Ctx: Send + Sync + 'static,
+    {
+        self.common_worker_setup(executor, None, instances)
+    }
+
+    pub(crate) async fn build_instance<LS, Req, E, Res, Ctx>(
         instance: usize,
         service: LS,
         worker: Worker<Context<E>>,
-        notifier: WorkerNotify<Result<Option<Request<J>>, Error>>,
+        notifier: WorkerNotify<Result<Option<Request<Req, Ctx>>, Error>>,
     ) where
-        LS: Service<Request<J>, Response = Res> + Send + 'static,
+        LS: Service<Request<Req, Ctx>, Response = Res> + Send + 'static,
         LS::Future: Send + 'static,
         LS::Response: 'static,
         LS::Error: Send + Sync + Into<BoxDynError> + 'static,
-        P: Backend<Request<J>, Res>,
+        P: Backend<Request<Req, Ctx>, Res>,
         E: Executor + Send + Clone + 'static + Sync,
     {
         if let Some(ctx) = worker.state.context.as_ref() {
@@ -502,12 +456,20 @@ impl<S, P> Worker<Ready<S, P>> {
                             Ok(Ok(Some(req))) => {
                                 let fut = service.call(req);
                                 let worker_id = worker_id.clone();
+                                let w = worker.clone();
                                 let state = worker.state.clone();
                                 worker.spawn(fut.map(move |res| {
                                     if let Err(e) = res {
+                                        let error = e.into();
+                                        if let Some(Error::MissingData(e)) =
+                                            error.downcast_ref::<Error>()
+                                        {
+                                            w.force_stop();
+                                            unreachable!("Worker missing required context: {}", e);
+                                        }
                                         if let Some(ctx) = state.context.as_ref() {
                                             ctx.notify(Worker {
-                                                state: Event::Error(e.into()),
+                                                state: Event::Error(error),
                                                 id: WorkerId::new_with_instance(
                                                     worker_id.name(),
                                                     instance,
@@ -551,6 +513,7 @@ impl<S, P> Worker<Ready<S, P>> {
         }
     }
 }
+
 /// Stores the Workers context
 #[derive(Clone)]
 pub struct Context<E> {
@@ -571,6 +534,12 @@ impl<E> fmt::Debug for Context<E> {
     }
 }
 
+impl<Req, Ctx, E: Send + Sync + Clone + 'static> FromRequest<Request<Req, Ctx>> for Context<E> {
+    fn from_request(req: &Request<Req, Ctx>) -> Result<Self, Error> {
+        req.get_checked::<Self>().cloned()
+    }
+}
+
 pin_project! {
     struct Tracked<F, E> {
         worker: Context<E>,
@@ -648,7 +617,7 @@ impl<E: Executor + Send + 'static + Clone> Context<E> {
     pub fn is_shutting_down(&self) -> bool {
         self.context
             .as_ref()
-            .map(|s| s.shutdown().is_shutting_down())
+            .map(|s| !self.is_running() || s.shutdown().is_shutting_down())
             .unwrap_or(!self.is_running())
     }
 
@@ -661,7 +630,7 @@ impl<E: Executor + Send + 'static + Clone> Context<E> {
     }
 }
 
-impl<E: Executor + Send + Clone + 'static + Sync> FromData for Context<E> {}
+// impl<E: Executor + Send + Clone + 'static + Sync> FromRequest for Context<E> {}
 
 impl<E: Executor + Send + Clone + 'static> Future for Context<E> {
     type Output = ();
@@ -686,7 +655,7 @@ impl<E: Executor + Send + Clone + 'static> Future for Context<E> {
 
 #[cfg(test)]
 mod tests {
-    use std::{io, ops::Deref, sync::atomic::AtomicUsize, time::Duration};
+    use std::{ops::Deref, sync::atomic::AtomicUsize, time::Duration};
 
     #[derive(Debug, Clone)]
     struct TokioTestExecutor;
@@ -754,15 +723,13 @@ mod tests {
             }
         }
 
-        async fn task(job: u32, count: Data<Count>) -> Result<(), io::Error> {
+        async fn task(job: u32, count: Data<Count>) {
             count.fetch_add(1, Ordering::Relaxed);
             if job == ITEMS - 1 {
                 tokio::time::sleep(Duration::from_secs(1)).await;
             }
-            Ok(())
         }
         let worker = WorkerBuilder::new("rango-tango")
-            // .chain(|svc| svc.timeout(Duration::from_millis(500)))
             .data(Count::default())
             .backend(in_memory);
         let worker = worker.build_fn(task);
diff --git a/packages/apalis-cron/src/lib.rs b/packages/apalis-cron/src/lib.rs
index afe5402..9680ec7 100644
--- a/packages/apalis-cron/src/lib.rs
+++ b/packages/apalis-cron/src/lib.rs
@@ -57,14 +57,13 @@
 //! }
 //! ```
 
-use apalis_core::data::Extensions;
 use apalis_core::layers::Identity;
 use apalis_core::poller::Poller;
 use apalis_core::request::RequestStream;
-use apalis_core::task::task_id::TaskId;
+use apalis_core::task::namespace::Namespace;
 use apalis_core::worker::WorkerId;
 use apalis_core::Backend;
-use apalis_core::{error::Error, request::Request, task::attempt::Attempt};
+use apalis_core::{error::Error, request::Request};
 use chrono::{DateTime, TimeZone, Utc};
 pub use cron::Schedule;
 use std::marker::PhantomData;
@@ -102,14 +101,14 @@ where
         }
     }
 }
-impl<J, Tz> CronStream<J, Tz>
+impl<Req, Tz> CronStream<Req, Tz>
 where
-    J: From<DateTime<Tz>> + Send + Sync + 'static,
+    Req: From<DateTime<Tz>> + Send + Sync + 'static,
     Tz: TimeZone + Send + Sync + 'static,
     Tz::Offset: Send + Sync,
 {
     /// Convert to consumable
-    fn into_stream(self) -> RequestStream<Request<J>> {
+    fn into_stream(self) -> RequestStream<Request<Req, ()>> {
         let timezone = self.timezone.clone();
         let stream = async_stream::stream! {
             let mut schedule = self.schedule.upcoming_owned(timezone.clone());
@@ -120,10 +119,11 @@ where
                         let to_sleep = next - timezone.from_utc_datetime(&Utc::now().naive_utc());
                         let to_sleep = to_sleep.to_std().map_err(|e| Error::SourceError(Arc::new(e.into())))?;
                         apalis_core::sleep(to_sleep).await;
-                        let mut data = Extensions::new();
-                        data.insert(TaskId::new());
-                        data.insert(Attempt::default());
-                        yield Ok(Some(Request::new_with_data(J::from(timezone.from_utc_datetime(&Utc::now().naive_utc())), data)));
+                        let timestamp = timezone.from_utc_datetime(&Utc::now().naive_utc());
+                        let namespace = Namespace(format!("{}:{timestamp:?}", self.schedule));
+                        let mut req = Request::new(Req::from(timestamp));
+                        req.parts.namespace = Some(namespace);
+                        yield Ok(Some(req));
                     },
                     None => {
                         yield Ok(None);
@@ -135,13 +135,13 @@ where
     }
 }
 
-impl<J, Tz, Res> Backend<Request<J>, Res> for CronStream<J, Tz>
+impl<Req, Tz, Res> Backend<Request<Req, ()>, Res> for CronStream<Req, Tz>
 where
-    J: From<DateTime<Tz>> + Send + Sync + 'static,
+    Req: From<DateTime<Tz>> + Send + Sync + 'static,
     Tz: TimeZone + Send + Sync + 'static,
     Tz::Offset: Send + Sync,
 {
-    type Stream = RequestStream<Request<J>>;
+    type Stream = RequestStream<Request<Req, ()>>;
 
     type Layer = Identity;
 
diff --git a/packages/apalis-redis/src/lib.rs b/packages/apalis-redis/src/lib.rs
index 8257be3..01c8c04 100644
--- a/packages/apalis-redis/src/lib.rs
+++ b/packages/apalis-redis/src/lib.rs
@@ -30,6 +30,6 @@
 mod storage;
 pub use storage::connect;
 pub use storage::Config;
-pub use storage::RedisJob;
+pub use storage::RedisContext;
 pub use storage::RedisQueueInfo;
 pub use storage::RedisStorage;
diff --git a/packages/apalis-redis/src/storage.rs b/packages/apalis-redis/src/storage.rs
index e5e2cf0..ec595f0 100644
--- a/packages/apalis-redis/src/storage.rs
+++ b/packages/apalis-redis/src/storage.rs
@@ -1,13 +1,13 @@
 use apalis_core::codec::json::JsonCodec;
-use apalis_core::data::Extensions;
 use apalis_core::error::Error;
 use apalis_core::layers::{Ack, AckLayer, Service};
 use apalis_core::poller::controller::Controller;
 use apalis_core::poller::stream::BackendStream;
 use apalis_core::poller::Poller;
-use apalis_core::request::{Request, RequestStream};
+use apalis_core::request::{Parts, Request, RequestStream};
+use apalis_core::response::Response;
+use apalis_core::service_fn::FromRequest;
 use apalis_core::storage::Storage;
-use apalis_core::task::attempt::Attempt;
 use apalis_core::task::namespace::Namespace;
 use apalis_core::task::task_id::TaskId;
 use apalis_core::worker::WorkerId;
@@ -92,90 +92,20 @@ struct RedisScript {
     vacuum: Script,
 }
 
-/// The actual structure of a Redis job
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RedisJob<J> {
-    /// The job context
-    ctx: Context,
-    /// The inner job
-    job: J,
-}
-
-impl<J> RedisJob<J> {
-    /// Creates a new RedisJob.
-    pub fn new(job: J, ctx: Context) -> Self {
-        RedisJob { ctx, job }
-    }
-
-    /// Gets a reference to the context.
-    pub fn ctx(&self) -> &Context {
-        &self.ctx
-    }
-
-    /// Gets a mutable reference to the context.
-    pub fn ctx_mut(&mut self) -> &mut Context {
-        &mut self.ctx
-    }
-
-    /// Sets the context.
-    pub fn set_ctx(&mut self, ctx: Context) {
-        self.ctx = ctx;
-    }
-
-    /// Gets a reference to the job.
-    pub fn job(&self) -> &J {
-        &self.job
-    }
-
-    /// Gets a mutable reference to the job.
-    pub fn job_mut(&mut self) -> &mut J {
-        &mut self.job
-    }
-
-    /// Sets the job.
-    pub fn set_job(&mut self, job: J) {
-        self.job = job;
-    }
-
-    /// Combines context and job into a tuple.
-    pub fn into_tuple(self) -> (Context, J) {
-        (self.ctx, self.job)
-    }
-}
-
-impl<T> From<RedisJob<T>> for Request<T> {
-    fn from(val: RedisJob<T>) -> Self {
-        let mut data = Extensions::new();
-        data.insert(val.ctx.id.clone());
-        data.insert(val.ctx.attempts.clone());
-        data.insert(val.ctx);
-        Request::new_with_data(val.job, data)
-    }
-}
-
-impl<T> TryFrom<Request<T>> for RedisJob<T> {
-    type Error = RedisError;
-    fn try_from(val: Request<T>) -> Result<Self, Self::Error> {
-        let ctx = val
-            .get::<Context>()
-            .cloned()
-            .ok_or((ErrorKind::IoError, "Missing Context"))?;
-        Ok(RedisJob {
-            job: val.take(),
-            ctx,
-        })
-    }
-}
-
+/// The context for a redis storage job
 #[derive(Clone, Debug, Serialize, Deserialize, Default)]
-pub struct Context {
-    id: TaskId,
-    attempts: Attempt,
+pub struct RedisContext {
     max_attempts: usize,
     lock_by: Option<WorkerId>,
     run_at: Option<SystemTime>,
 }
 
+impl<Req> FromRequest<Request<Req, RedisContext>> for RedisContext {
+    fn from_request(req: &Request<Req, RedisContext>) -> Result<Self, Error> {
+        Ok(req.parts.context.clone())
+    }
+}
+
 /// Config for a [RedisStorage]
 #[derive(Clone, Debug)]
 pub struct Config {
@@ -448,18 +378,18 @@ impl<T, Conn, C> RedisStorage<T, Conn, C> {
     }
 }
 
-impl<T, Conn, C, Res> Backend<Request<T>, Res> for RedisStorage<T, Conn, C>
+impl<T, Conn, C, Res> Backend<Request<T, RedisContext>, Res> for RedisStorage<T, Conn, C>
 where
     T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static,
     Conn: ConnectionLike + Send + Sync + 'static,
     Res: Send + Serialize + Sync + 'static,
     C: Codec<Compact = Vec<u8>> + Send + 'static,
 {
-    type Stream = BackendStream<RequestStream<Request<T>>>;
+    type Stream = BackendStream<RequestStream<Request<T, RedisContext>>>;
 
-    type Layer = AckLayer<Sender<(Context, Result<Res, Error>)>, T, Res>;
+    type Layer = AckLayer<Sender<(RedisContext, Response<Res>)>, T, RedisContext, Res>;
 
-    fn poll<Svc: Service<Request<T>>>(
+    fn poll<Svc: Service<Request<T, RedisContext>>>(
         mut self,
         worker: WorkerId,
     ) -> Poller<Self::Stream, Self::Layer> {
@@ -468,7 +398,7 @@ where
         let layer = AckLayer::new(ack);
         let controller = self.controller.clone();
         let config = self.config.clone();
-        let stream: RequestStream<Request<T>> = Box::pin(rx);
+        let stream: RequestStream<Request<T, RedisContext>> = Box::pin(rx);
         let heartbeat = async move {
             let mut keep_alive_stm = apalis_core::interval::interval(config.keep_alive).fuse();
 
@@ -536,13 +466,9 @@ where
     Conn: ConnectionLike + Send + Sync + 'static,
     C: Codec<Compact = Vec<u8>> + Send,
 {
-    type Context = Context;
+    type Context = RedisContext;
     type AckError = RedisError;
-    async fn ack(
-        &mut self,
-        ctx: &Self::Context,
-        res: &Result<Res, Error>,
-    ) -> Result<(), RedisError> {
+    async fn ack(&mut self, ctx: &Self::Context, res: &Response<Res>) -> Result<(), RedisError> {
         let inflight_set = format!(
             "{}:{}",
             self.config.inflight_jobs_set(),
@@ -550,8 +476,8 @@ where
         );
 
         let now: i64 = Utc::now().timestamp();
-
-        match res {
+        let task_id = res.task_id.to_string();
+        match &res.inner {
             Ok(success_res) => {
                 let done_job = self.scripts.done_job.clone();
                 let done_jobs_set = &self.config.done_jobs_set();
@@ -559,7 +485,7 @@ where
                     .key(inflight_set)
                     .key(done_jobs_set)
                     .key(self.config.job_data_hash())
-                    .arg(ctx.id.to_string())
+                    .arg(task_id)
                     .arg(now)
                     .arg(C::encode(success_res).map_err(Into::into).unwrap())
                     .invoke_async(&mut self.conn)
@@ -567,27 +493,26 @@ where
             }
             Err(e) => match e {
                 Error::Abort(e) => {
-                    let retry_job = self.scripts.retry_job.clone();
-                    let retry_jobs_set = &self.config.scheduled_jobs_set();
-                    retry_job
+                    let kill_job = self.scripts.kill_job.clone();
+                    let kill_jobs_set = &self.config.dead_jobs_set();
+                    kill_job
                         .key(inflight_set)
-                        .key(retry_jobs_set)
+                        .key(kill_jobs_set)
                         .key(self.config.job_data_hash())
-                        .arg(ctx.id.to_string())
+                        .arg(task_id)
                         .arg(now)
                         .arg(e.to_string())
                         .invoke_async(&mut self.conn)
                         .await
                 }
-
                 _ => {
-                    let kill_job = self.scripts.kill_job.clone();
-                    let kill_jobs_set = &self.config.dead_jobs_set();
-                    kill_job
+                    let retry_job = self.scripts.retry_job.clone();
+                    let retry_jobs_set = &self.config.scheduled_jobs_set();
+                    retry_job
                         .key(inflight_set)
-                        .key(kill_jobs_set)
+                        .key(retry_jobs_set)
                         .key(self.config.job_data_hash())
-                        .arg(ctx.id.to_string())
+                        .arg(task_id)
                         .arg(now)
                         .arg(e.to_string())
                         .invoke_async(&mut self.conn)
@@ -604,14 +529,17 @@ where
     Conn: ConnectionLike + Send + Sync + 'static,
     C: Codec<Compact = Vec<u8>>,
 {
-    async fn fetch_next(&mut self, worker_id: &WorkerId) -> Result<Vec<Request<T>>, RedisError> {
+    async fn fetch_next(
+        &mut self,
+        worker_id: &WorkerId,
+    ) -> Result<Vec<Request<T, RedisContext>>, RedisError> {
         let fetch_jobs = self.scripts.get_jobs.clone();
         let consumers_set = self.config.consumers_set();
         let active_jobs_list = self.config.active_jobs_list();
         let job_data_hash = self.config.job_data_hash();
         let inflight_set = format!("{}:{}", self.config.inflight_jobs_set(), worker_id);
         let signal_list = self.config.signal_list();
-        let namespace = self.config.namespace.clone();
+        let namespace = &self.config.namespace;
 
         let result = fetch_jobs
             .key(&consumers_set)
@@ -629,11 +557,10 @@ where
                 let mut processed = vec![];
                 for job in jobs {
                     let bytes = deserialize_job(&job)?;
-                    let mut request: RedisJob<T> = C::decode(bytes.to_vec())
+                    let mut request: Request<T, RedisContext> = C::decode(bytes.to_vec())
                         .map_err(|e| build_error(&e.into().to_string()))?;
-                    request.ctx_mut().lock_by = Some(worker_id.clone());
-                    let mut request: Request<T> = request.into();
-                    request.insert(Namespace(namespace.clone()));
+                    request.parts.context.lock_by = Some(worker_id.clone());
+                    request.parts.namespace = Some(Namespace(namespace.clone()));
                     processed.push(request)
                 }
                 Ok(processed)
@@ -692,53 +619,50 @@ where
 {
     type Job = T;
     type Error = RedisError;
-    type Identifier = TaskId;
+    type Context = RedisContext;
 
-    async fn push(&mut self, job: Self::Job) -> Result<TaskId, RedisError> {
+    async fn push_request(
+        &mut self,
+        req: Request<T, RedisContext>,
+    ) -> Result<Parts<Self::Context>, RedisError> {
         let conn = &mut self.conn;
         let push_job = self.scripts.push_job.clone();
         let job_data_hash = self.config.job_data_hash();
         let active_jobs_list = self.config.active_jobs_list();
         let signal_list = self.config.signal_list();
-        let job_id = TaskId::new();
-        let ctx = Context {
-            id: job_id.clone(),
-            ..Default::default()
-        };
-        let job = C::encode(&RedisJob { ctx, job })
+
+        let job = C::encode(&req)
             .map_err(|e| (ErrorKind::IoError, "Encode error", e.into().to_string()))?;
         push_job
             .key(job_data_hash)
             .key(active_jobs_list)
             .key(signal_list)
-            .arg(job_id.to_string())
+            .arg(req.parts.task_id.to_string())
             .arg(job)
             .invoke_async(conn)
             .await?;
-        Ok(job_id.clone())
+        Ok(req.parts)
     }
 
-    async fn schedule(&mut self, job: Self::Job, on: i64) -> Result<TaskId, RedisError> {
+    async fn schedule_request(
+        &mut self,
+        req: Request<Self::Job, RedisContext>,
+        on: i64,
+    ) -> Result<Parts<Self::Context>, RedisError> {
         let schedule_job = self.scripts.schedule_job.clone();
         let job_data_hash = self.config.job_data_hash();
         let scheduled_jobs_set = self.config.scheduled_jobs_set();
-        let job_id = TaskId::new();
-        let ctx = Context {
-            id: job_id.clone(),
-            ..Default::default()
-        };
-        let job = RedisJob { job, ctx };
-        let job = C::encode(&job)
+        let job = C::encode(&req)
             .map_err(|e| (ErrorKind::IoError, "Encode error", e.into().to_string()))?;
         schedule_job
             .key(job_data_hash)
             .key(scheduled_jobs_set)
-            .arg(job_id.to_string())
+            .arg(req.parts.task_id.to_string())
             .arg(job)
             .arg(on)
             .invoke_async(&mut self.conn)
             .await?;
-        Ok(job_id.clone())
+        Ok(req.parts)
     }
 
     async fn len(&mut self) -> Result<i64, RedisError> {
@@ -758,7 +682,7 @@ where
     async fn fetch_by_id(
         &mut self,
         job_id: &TaskId,
-    ) -> Result<Option<Request<Self::Job>>, RedisError> {
+    ) -> Result<Option<Request<Self::Job, RedisContext>>, RedisError> {
         let data: Value = redis::cmd("HMGET")
             .arg(&self.config.job_data_hash())
             .arg(job_id.to_string())
@@ -766,34 +690,32 @@ where
             .await?;
         let bytes = deserialize_job(&data)?;
 
-        let inner: RedisJob<T> = C::decode(bytes.to_vec())
+        let inner: Request<T, RedisContext> = C::decode(bytes.to_vec())
             .map_err(|e| (ErrorKind::IoError, "Decode error", e.into().to_string()))?;
-        Ok(Some(inner.into()))
+        Ok(Some(inner))
     }
-    async fn update(&mut self, job: Request<T>) -> Result<(), RedisError> {
-        let job: RedisJob<T> = job.try_into()?;
+    async fn update(&mut self, job: Request<T, RedisContext>) -> Result<(), RedisError> {
+        let task_id = job.parts.task_id.to_string();
         let bytes = C::encode(&job)
             .map_err(|e| (ErrorKind::IoError, "Encode error", e.into().to_string()))?;
         let _: i64 = redis::cmd("HSET")
             .arg(&self.config.job_data_hash())
-            .arg(job.ctx.id.to_string())
+            .arg(task_id)
             .arg(bytes)
             .query_async(&mut self.conn)
             .await?;
         Ok(())
     }
 
-    async fn reschedule(&mut self, job: Request<T>, wait: Duration) -> Result<(), RedisError> {
+    async fn reschedule(
+        &mut self,
+        job: Request<T, RedisContext>,
+        wait: Duration,
+    ) -> Result<(), RedisError> {
         let schedule_job = self.scripts.schedule_job.clone();
-        let job_id = job
-            .get::<TaskId>()
-            .cloned()
-            .ok_or((ErrorKind::IoError, "Missing TaskId"))?;
-        let worker_id = job
-            .get::<WorkerId>()
-            .cloned()
-            .ok_or((ErrorKind::IoError, "Missing WorkerId"))?;
-        let job = C::encode::<RedisJob<T>>(job.try_into()?)
+        let job_id = &job.parts.task_id;
+        let worker_id = &job.parts.context.lock_by.clone().unwrap();
+        let job = C::encode(&job)
             .map_err(|e| (ErrorKind::IoError, "Encode error", e.into().to_string()))?;
         let job_data_hash = self.config.job_data_hash();
         let scheduled_jobs_set = self.config.scheduled_jobs_set();
@@ -859,7 +781,7 @@ where
         let conn = &mut self.conn;
         match res {
             Some(job) => {
-                let attempt = job.get::<Attempt>().cloned().unwrap_or_default();
+                let attempt = &job.parts.attempt;
                 if attempt.current() >= self.config.max_retries {
                     redis::cmd("ZADD")
                         .arg(failed_jobs_set)
@@ -870,7 +792,7 @@ where
                     self.kill(worker_id, task_id).await?;
                     return Ok(1);
                 }
-                let job = C::encode::<RedisJob<T>>(job.try_into()?)
+                let job = C::encode(job)
                     .map_err(|e| (ErrorKind::IoError, "Encode error", e.into().to_string()))?;
 
                 let res: Result<i32, RedisError> = retry_job
@@ -1024,7 +946,7 @@ mod tests {
     async fn consume_one(
         storage: &mut RedisStorage<Email>,
         worker_id: &WorkerId,
-    ) -> Request<Email> {
+    ) -> Request<Email, RedisContext> {
         let stream = storage.fetch_next(worker_id);
         stream
             .await
@@ -1052,7 +974,10 @@ mod tests {
         storage.push(email).await.expect("failed to push a job");
     }
 
-    async fn get_job(storage: &mut RedisStorage<Email>, job_id: &TaskId) -> Request<Email> {
+    async fn get_job(
+        storage: &mut RedisStorage<Email>,
+        job_id: &TaskId,
+    ) -> Request<Email, RedisContext> {
         storage
             .fetch_by_id(job_id)
             .await
@@ -1078,14 +1003,17 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<Context>().unwrap();
-
+        let ctx = &job.parts.context;
+        let res = 42usize;
         storage
-            .ack(ctx, &Ok(()))
+            .ack(
+                ctx,
+                &Response::success(res, job.parts.task_id.clone(), job.parts.attempt.clone()),
+            )
             .await
             .expect("failed to acknowledge the job");
 
-        let _job = get_job(&mut storage, &ctx.id).await;
+        let _job = get_job(&mut storage, &job.parts.task_id).await;
     }
 
     #[tokio::test]
@@ -1097,7 +1025,7 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let job_id = &job.get::<Context>().unwrap().id;
+        let job_id = &job.parts.task_id;
 
         storage
             .kill(&worker_id, &job_id)
diff --git a/packages/apalis-sql/src/context.rs b/packages/apalis-sql/src/context.rs
index fbbf77e..44cb063 100644
--- a/packages/apalis-sql/src/context.rs
+++ b/packages/apalis-sql/src/context.rs
@@ -1,5 +1,6 @@
 use apalis_core::error::Error;
-use apalis_core::task::{attempt::Attempt, task_id::TaskId};
+use apalis_core::request::Request;
+use apalis_core::service_fn::FromRequest;
 use apalis_core::worker::WorkerId;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -7,12 +8,10 @@ use std::{fmt, str::FromStr};
 
 /// The context for a job is represented here
 /// Used to provide a context for a job with an sql backend
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct SqlContext {
-    id: TaskId,
     status: State,
     run_at: DateTime<Utc>,
-    attempts: Attempt,
     max_attempts: i32,
     last_error: Option<String>,
     lock_at: Option<i64>,
@@ -21,15 +20,13 @@ pub struct SqlContext {
 }
 
 impl SqlContext {
-    /// Build a new context with defaults given an ID.
-    pub fn new(id: TaskId) -> Self {
+    /// Build a new context with defaults
+    pub fn new() -> Self {
         SqlContext {
-            id,
             status: State::Pending,
             run_at: Utc::now(),
             lock_at: None,
             done_at: None,
-            attempts: Default::default(),
             max_attempts: 25,
             last_error: None,
             lock_by: None,
@@ -46,21 +43,6 @@ impl SqlContext {
         self.max_attempts
     }
 
-    /// Get the id for a job
-    pub fn id(&self) -> &TaskId {
-        &self.id
-    }
-
-    /// Gets the current attempts for a job. Default 0
-    pub fn attempts(&self) -> &Attempt {
-        &self.attempts
-    }
-
-    /// Set the number of attempts
-    pub fn set_attempts(&mut self, attempts: i32) {
-        self.attempts = Attempt::new_with_value(attempts.try_into().unwrap());
-    }
-
     /// Get the time a job was done
     pub fn done_at(&self) -> &Option<i64> {
         &self.done_at
@@ -120,10 +102,11 @@ impl SqlContext {
     pub fn set_last_error(&mut self, error: Option<String>) {
         self.last_error = error;
     }
+}
 
-    /// Record an attempt to execute the request
-    pub fn record_attempt(&mut self) {
-        self.attempts.increment();
+impl<Req> FromRequest<Request<Req, SqlContext>> for SqlContext {
+    fn from_request(req: &Request<Req, SqlContext>) -> Result<Self, Error> {
+        Ok(req.parts.context.clone())
     }
 }
 
@@ -159,7 +142,7 @@ impl FromStr for State {
             "Done" => Ok(State::Done),
             "Failed" => Ok(State::Failed),
             "Killed" => Ok(State::Killed),
-            _ => Err(Error::MissingContext("Invalid Job state".to_string())),
+            _ => Err(Error::MissingData("Invalid Job state".to_string())),
         }
     }
 }
diff --git a/packages/apalis-sql/src/from_row.rs b/packages/apalis-sql/src/from_row.rs
index bcc2a65..d242e4a 100644
--- a/packages/apalis-sql/src/from_row.rs
+++ b/packages/apalis-sql/src/from_row.rs
@@ -1,5 +1,7 @@
+use apalis_core::request::Parts;
+use apalis_core::task::attempt::Attempt;
 use apalis_core::task::task_id::TaskId;
-use apalis_core::{data::Extensions, request::Request, worker::WorkerId};
+use apalis_core::{request::Request, worker::WorkerId};
 
 use serde::{Deserialize, Serialize};
 use sqlx::{Decode, Type};
@@ -8,60 +10,43 @@ use crate::context::SqlContext;
 /// Wrapper for [Request]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SqlRequest<T> {
-    req: T,
-    context: SqlContext,
+    pub(crate) req: Request<T, SqlContext>,
 }
 
 impl<T> SqlRequest<T> {
     /// Creates a new SqlRequest.
-    pub fn new(req: T, context: SqlContext) -> Self {
-        SqlRequest { req, context }
+    pub fn new(req: Request<T, SqlContext>) -> Self {
+        SqlRequest { req }
     }
 
     /// Gets a reference to the request.
     pub fn req(&self) -> &T {
-        &self.req
+        &self.req.args
     }
 
     /// Gets a mutable reference to the request.
     pub fn req_mut(&mut self) -> &mut T {
-        &mut self.req
+        &mut self.req.args
     }
 
     /// Sets the request.
     pub fn set_req(&mut self, req: T) {
-        self.req = req;
+        self.req.args = req;
     }
 
     /// Gets a reference to the context.
     pub fn context(&self) -> &SqlContext {
-        &self.context
+        &self.req.parts.context
     }
 
     /// Gets a mutable reference to the context.
     pub fn context_mut(&mut self) -> &mut SqlContext {
-        &mut self.context
+        &mut self.req.parts.context
     }
 
     /// Sets the context.
     pub fn set_context(&mut self, context: SqlContext) {
-        self.context = context;
-    }
-
-    /// Combines request and context into a tuple.
-    pub fn into_tuple(self) -> (T, SqlContext) {
-        (self.req, self.context)
-    }
-}
-
-impl<T> From<SqlRequest<T>> for Request<T> {
-    fn from(val: SqlRequest<T>) -> Self {
-        let mut data = Extensions::new();
-        data.insert(val.context.id().clone());
-        data.insert(val.context.attempts().clone());
-        data.insert(val.context);
-
-        Request::new_with_data(val.req, data)
+        self.req.parts.context = context;
     }
 }
 
@@ -76,19 +61,22 @@ impl<'r, T: Decode<'r, sqlx::Sqlite> + Type<sqlx::Sqlite>>
         use std::str::FromStr;
 
         let job: T = row.try_get("job")?;
-        let id: TaskId =
+        let task_id: TaskId =
             TaskId::from_str(row.try_get("id")?).map_err(|e| sqlx::Error::ColumnDecode {
                 index: "id".to_string(),
                 source: Box::new(e),
             })?;
-        let mut context = crate::context::SqlContext::new(id);
+        let mut parts = Parts::<SqlContext>::default();
+        parts.task_id = task_id;
+
+        let attempt: i32 = row.try_get("attempts").unwrap_or(0);
+        parts.attempt = Attempt::new_with_value(attempt as usize);
+
+        let mut context = crate::context::SqlContext::new();
 
         let run_at: i64 = row.try_get("run_at")?;
         context.set_run_at(DateTime::from_timestamp(run_at, 0).unwrap_or_default());
 
-        let attempts = row.try_get("attempts").unwrap_or(0);
-        context.set_attempts(attempts);
-
         let max_attempts = row.try_get("max_attempts").unwrap_or(25);
         context.set_max_attempts(max_attempts);
 
@@ -118,8 +106,10 @@ impl<'r, T: Decode<'r, sqlx::Sqlite> + Type<sqlx::Sqlite>>
                     source: "Could not parse lock_by as a WorkerId".into(),
                 })?,
         );
-
-        Ok(SqlRequest { context, req: job })
+        parts.context = context;
+        Ok(SqlRequest {
+            req: Request::new_with_parts(job, parts),
+        })
     }
 }
 
@@ -134,19 +124,21 @@ impl<'r, T: Decode<'r, sqlx::Postgres> + Type<sqlx::Postgres>>
         use std::str::FromStr;
 
         let job: T = row.try_get("job")?;
-        let id: TaskId =
+        let task_id: TaskId =
             TaskId::from_str(row.try_get("id")?).map_err(|e| sqlx::Error::ColumnDecode {
                 index: "id".to_string(),
                 source: Box::new(e),
             })?;
-        let mut context = SqlContext::new(id);
+        let mut parts = Parts::<SqlContext>::default();
+        parts.task_id = task_id;
+
+        let attempt: i32 = row.try_get("attempts").unwrap_or(0);
+        parts.attempt = Attempt::new_with_value(attempt as usize);
+        let mut context = SqlContext::new();
 
         let run_at = row.try_get("run_at")?;
         context.set_run_at(run_at);
 
-        let attempts = row.try_get("attempts").unwrap_or(0);
-        context.set_attempts(attempts);
-
         let max_attempts = row.try_get("max_attempts").unwrap_or(25);
         context.set_max_attempts(max_attempts);
 
@@ -176,7 +168,10 @@ impl<'r, T: Decode<'r, sqlx::Postgres> + Type<sqlx::Postgres>>
                     source: "Could not parse lock_by as a WorkerId".into(),
                 })?,
         );
-        Ok(SqlRequest { context, req: job })
+        parts.context = context;
+        Ok(SqlRequest {
+            req: Request::new_with_parts(job, parts),
+        })
     }
 }
 
@@ -189,19 +184,22 @@ impl<'r, T: Decode<'r, sqlx::MySql> + Type<sqlx::MySql>> sqlx::FromRow<'r, sqlx:
         use sqlx::Row;
         use std::str::FromStr;
         let job: T = row.try_get("job")?;
-        let id: TaskId =
+        let task_id: TaskId =
             TaskId::from_str(row.try_get("id")?).map_err(|e| sqlx::Error::ColumnDecode {
                 index: "id".to_string(),
                 source: Box::new(e),
             })?;
-        let mut context = SqlContext::new(id);
+        let mut parts = Parts::<SqlContext>::default();
+        parts.task_id = task_id;
+
+        let attempt: i32 = row.try_get("attempts").unwrap_or(0);
+        parts.attempt = Attempt::new_with_value(attempt as usize);
+
+        let mut context = SqlContext::new();
 
         let run_at = row.try_get("run_at")?;
         context.set_run_at(run_at);
 
-        let attempts = row.try_get("attempts").unwrap_or(0);
-        context.set_attempts(attempts);
-
         let max_attempts = row.try_get("max_attempts").unwrap_or(25);
         context.set_max_attempts(max_attempts);
 
@@ -231,7 +229,9 @@ impl<'r, T: Decode<'r, sqlx::MySql> + Type<sqlx::MySql>> sqlx::FromRow<'r, sqlx:
                     source: "Could not parse lock_by as a WorkerId".into(),
                 })?,
         );
-
-        Ok(SqlRequest { context, req: job })
+        parts.context = context;
+        Ok(SqlRequest {
+            req: Request::new_with_parts(job, parts),
+        })
     }
 }
diff --git a/packages/apalis-sql/src/lib.rs b/packages/apalis-sql/src/lib.rs
index b671bb1..012dfcd 100644
--- a/packages/apalis-sql/src/lib.rs
+++ b/packages/apalis-sql/src/lib.rs
@@ -12,6 +12,7 @@
 
 use std::time::Duration;
 
+use apalis_core::error::Error;
 use context::State;
 
 /// The context of the sql job
@@ -130,11 +131,11 @@ impl Config {
 }
 
 /// Calculates the status from a result
-pub fn calculate_status<Res>(res: &Result<Res, apalis_core::error::Error>) -> State {
+pub fn calculate_status<Res>(res: &Result<Res, Error>) -> State {
     match res {
         Ok(_) => State::Done,
         Err(e) => match &e {
-            _ if e.to_string().starts_with("AbortError") => State::Killed,
+            Error::Abort(_) => State::Killed,
             _ => State::Failed,
         },
     }
@@ -144,7 +145,8 @@ pub fn calculate_status<Res>(res: &Result<Res, apalis_core::error::Error>) -> St
 #[macro_export]
 macro_rules! sql_storage_tests {
     ($setup:path, $storage_type:ty, $job_type:ty) => {
-        async fn setup_test_wrapper() -> TestWrapper<$storage_type, $job_type, ()> {
+        async fn setup_test_wrapper(
+        ) -> TestWrapper<$storage_type, Request<$job_type, SqlContext>, ()> {
             let (mut t, poller) = TestWrapper::new_with_service(
                 $setup().await,
                 apalis_core::service_fn::service_fn(email_service::send_email),
@@ -166,10 +168,14 @@ macro_rules! sql_storage_tests {
             let (job_id, res) = storage.execute_next().await;
             assert_eq!(res, Err("AbortError: Invalid character.".to_owned()));
             apalis_core::sleep(Duration::from_secs(1)).await;
-            let job = storage.fetch_by_id(&job_id).await.unwrap().unwrap();
-            let ctx = job.get::<SqlContext>().unwrap();
+            let job = storage
+                .fetch_by_id(&job_id)
+                .await
+                .unwrap()
+                .expect("No job found");
+            let ctx = job.parts.context;
             assert_eq!(*ctx.status(), State::Killed);
-            assert!(ctx.done_at().is_some());
+            // assert!(ctx.done_at().is_some());
             assert_eq!(
                 ctx.last_error().clone().unwrap(),
                 "{\"Err\":\"AbortError: Invalid character.\"}"
@@ -188,7 +194,7 @@ macro_rules! sql_storage_tests {
             assert_eq!(res, Ok("()".to_owned()));
             apalis_core::sleep(Duration::from_secs(1)).await;
             let job = storage.fetch_by_id(&job_id).await.unwrap().unwrap();
-            let ctx = job.get::<SqlContext>().unwrap();
+            let ctx = job.parts.context;
             assert_eq!(*ctx.status(), State::Done);
             assert!(ctx.done_at().is_some());
         }
@@ -209,9 +215,9 @@ macro_rules! sql_storage_tests {
             );
             apalis_core::sleep(Duration::from_secs(1)).await;
             let job = storage.fetch_by_id(&job_id).await.unwrap().unwrap();
-            let ctx = job.get::<SqlContext>().unwrap();
+            let ctx = job.parts.context;
             assert_eq!(*ctx.status(), State::Failed);
-            assert!(ctx.attempts().current() >= 1);
+            assert!(job.parts.attempt.current() >= 1);
             assert_eq!(
                 ctx.last_error().clone().unwrap(),
                 "{\"Err\":\"FailedError: Missing separator character '@'.\"}"
diff --git a/packages/apalis-sql/src/mysql.rs b/packages/apalis-sql/src/mysql.rs
index 1a88cf5..f42dca3 100644
--- a/packages/apalis-sql/src/mysql.rs
+++ b/packages/apalis-sql/src/mysql.rs
@@ -5,7 +5,8 @@ use apalis_core::notify::Notify;
 use apalis_core::poller::controller::Controller;
 use apalis_core::poller::stream::BackendStream;
 use apalis_core::poller::Poller;
-use apalis_core::request::{Request, RequestStream};
+use apalis_core::request::{Parts, Request, RequestStream};
+use apalis_core::response::Response;
 use apalis_core::storage::Storage;
 use apalis_core::task::namespace::Namespace;
 use apalis_core::task::task_id::TaskId;
@@ -43,7 +44,7 @@ where
     controller: Controller,
     config: Config,
     codec: PhantomData<C>,
-    ack_notify: Notify<(SqlContext, Result<C::Compact, apalis_core::error::Error>)>,
+    ack_notify: Notify<(SqlContext, Response<C::Compact>)>,
 }
 
 impl<T, C> fmt::Debug for MysqlStorage<T, C>
@@ -137,13 +138,10 @@ where
         worker_id: &WorkerId,
         interval: Duration,
         buffer_size: usize,
-        config: &Config,
-    ) -> impl Stream<Item = Result<Option<Request<T>>, sqlx::Error>> {
+    ) -> impl Stream<Item = Result<Option<Request<T, SqlContext>>, sqlx::Error>> {
         let pool = self.pool.clone();
         let worker_id = worker_id.to_string();
-        let config = config.clone();
         try_stream! {
-            let pool = pool.clone();
             let buffer_size = u32::try_from(buffer_size)
                     .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidInput, e)))?;
             loop {
@@ -180,13 +178,12 @@ where
 
                     for job in jobs {
                         yield {
-                            let (req, ctx) = job.into_tuple();
+                            let (req, ctx) = job.req.take_parts();
                             let req = C::decode(req)
                                 .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))
                                 .unwrap();
-                            let req = SqlRequest::new(req, ctx);
-                            let mut req: Request<T> = req.into();
-                            req.insert(Namespace(config.namespace.clone()));
+                            let mut req: Request<T, SqlContext> = Request::new_with_parts(req, ctx);
+                            req.parts.namespace = Some(Namespace(self.config.namespace.clone()));
                             Some(req)
                         }
                     }
@@ -228,50 +225,56 @@ where
 
     type Error = sqlx::Error;
 
-    type Identifier = TaskId;
+    type Context = SqlContext;
 
-    async fn push(&mut self, job: Self::Job) -> Result<TaskId, sqlx::Error> {
-        let id = TaskId::new();
+    async fn push_request(
+        &mut self,
+        job: Request<Self::Job, SqlContext>,
+    ) -> Result<Parts<SqlContext>, sqlx::Error> {
+        let (args, parts) = job.take_parts();
         let query =
             "INSERT INTO jobs VALUES (?, ?, ?, 'Pending', 0, 25, now(), NULL, NULL, NULL, NULL)";
         let pool = self.pool.clone();
 
-        let job = C::encode(job)
+        let job = C::encode(args)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
             .bind(job)
-            .bind(id.to_string())
+            .bind(parts.task_id.to_string())
             .bind(job_type.to_string())
             .execute(&pool)
             .await?;
-        Ok(id)
+        Ok(parts)
     }
 
-    async fn schedule(&mut self, job: Self::Job, on: i64) -> Result<TaskId, sqlx::Error> {
+    async fn schedule_request(
+        &mut self,
+        req: Request<Self::Job, SqlContext>,
+        on: i64,
+    ) -> Result<Parts<Self::Context>, sqlx::Error> {
         let query =
             "INSERT INTO jobs VALUES (?, ?, ?, 'Pending', 0, 25, ?, NULL, NULL, NULL, NULL)";
         let pool = self.pool.clone();
-        let id = TaskId::new();
 
-        let job = C::encode(job)
+        let args = C::encode(&req.args)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
 
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
-            .bind(job)
-            .bind(id.to_string())
+            .bind(args)
+            .bind(req.parts.task_id.to_string())
             .bind(job_type)
             .bind(on)
             .execute(&pool)
             .await?;
-        Ok(id)
+        Ok(req.parts)
     }
 
     async fn fetch_by_id(
         &mut self,
         job_id: &TaskId,
-    ) -> Result<Option<Request<Self::Job>>, sqlx::Error> {
+    ) -> Result<Option<Request<Self::Job, SqlContext>>, sqlx::Error> {
         let pool = self.pool.clone();
 
         let fetch_query = "SELECT * FROM jobs WHERE id = ?";
@@ -282,12 +285,11 @@ where
         match res {
             None => Ok(None),
             Some(job) => Ok(Some({
-                let (req, ctx) = job.into_tuple();
+                let (req, parts) = job.req.take_parts();
                 let req = C::decode(req)
                     .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
-                let req = SqlRequest::new(req, ctx);
-                let mut req: Request<T> = req.into();
-                req.insert(Namespace(self.config.namespace.clone()));
+                let mut req = Request::new_with_parts(req, parts);
+                req.parts.namespace = Some(Namespace(self.config.namespace.clone()));
                 req
             })),
         }
@@ -301,12 +303,13 @@ where
         record.try_get("count")
     }
 
-    async fn reschedule(&mut self, job: Request<T>, wait: Duration) -> Result<(), sqlx::Error> {
+    async fn reschedule(
+        &mut self,
+        job: Request<T, SqlContext>,
+        wait: Duration,
+    ) -> Result<(), sqlx::Error> {
         let pool = self.pool.clone();
-        let job_id = job.get::<TaskId>().ok_or(sqlx::Error::Io(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Missing TaskId",
-        )))?;
+        let job_id = job.parts.task_id.clone();
 
         let wait: i64 = wait
             .as_secs()
@@ -324,21 +327,16 @@ where
         Ok(())
     }
 
-    async fn update(&mut self, job: Request<Self::Job>) -> Result<(), sqlx::Error> {
+    async fn update(&mut self, job: Request<Self::Job, SqlContext>) -> Result<(), sqlx::Error> {
         let pool = self.pool.clone();
-        let ctx = job
-            .get::<SqlContext>()
-            .ok_or(sqlx::Error::Io(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "Missing TaskId",
-            )))?;
+        let ctx = job.parts.context;
         let status = ctx.status().to_string();
-        let attempts = ctx.attempts();
+        let attempts = job.parts.attempt;
         let done_at = *ctx.done_at();
         let lock_by = ctx.lock_by().clone();
         let lock_at = *ctx.lock_at();
         let last_error = ctx.last_error().clone();
-        let job_id = ctx.id();
+        let job_id = job.parts.task_id;
         let mut tx = pool.acquire().await?;
         let query =
                 "UPDATE jobs SET status = ?, attempts = ?, done_at = ?, lock_by = ?, lock_at = ?, last_error = ? WHERE id = ?";
@@ -372,14 +370,14 @@ where
     }
 }
 
-impl<T, Res, C> Backend<Request<T>, Res> for MysqlStorage<T, C>
+impl<Req, Res, C> Backend<Request<Req, SqlContext>, Res> for MysqlStorage<Req, C>
 where
-    T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static,
+    Req: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static,
     C: Debug + Codec<Compact = Value> + Clone + Send + 'static,
 {
-    type Stream = BackendStream<RequestStream<Request<T>>>;
+    type Stream = BackendStream<RequestStream<Request<Req, SqlContext>>>;
 
-    type Layer = AckLayer<MysqlStorage<T, C>, T, Res>;
+    type Layer = AckLayer<MysqlStorage<Req, C>, Req, SqlContext, Res>;
 
     fn poll<Svc>(self, worker: WorkerId) -> Poller<Self::Stream, Self::Layer> {
         let layer = AckLayer::new(self.clone());
@@ -389,7 +387,7 @@ where
         let ack_notify = self.ack_notify.clone();
         let mut hb_storage = self.clone();
         let stream = self
-            .stream_jobs(&worker, config.poll_interval, config.buffer_size, &config)
+            .stream_jobs(&worker, config.poll_interval, config.buffer_size)
             .map_err(|e| Error::SourceError(Arc::new(Box::new(e))));
         let stream = BackendStream::new(stream.boxed(), controller);
 
@@ -404,13 +402,13 @@ where
                     let query = "UPDATE jobs SET status = ?, done_at = now(), last_error = ?, attempts = ? WHERE id = ? AND lock_by = ?";
                     let query = sqlx::query(query);
                     let query = query
-                        .bind(calculate_status(&res).to_string())
+                        .bind(calculate_status(&res.inner).to_string())
                         .bind(
-                            serde_json::to_string(&res.as_ref().map_err(|e| e.to_string()))
+                            serde_json::to_string(&res.inner.as_ref().map_err(|e| e.to_string()))
                                 .unwrap(),
                         )
-                        .bind(ctx.attempts().current() as u64 + 1)
-                        .bind(ctx.id().to_string())
+                        .bind(res.attempt.current() as u64 + 1)
+                        .bind(res.task_id.to_string())
                         .bind(ctx.lock_by().as_ref().unwrap().to_string());
                     if let Err(e) = query.execute(&pool).await {
                         error!("Ack failed: {e}");
@@ -445,21 +443,13 @@ where
     T: Sync + Send,
     Res: Serialize + Send + 'static + Sync,
     C: Codec<Compact = Value> + Send,
+    C::Error: Debug,
 {
     type Context = SqlContext;
     type AckError = sqlx::Error;
-    async fn ack(
-        &mut self,
-        ctx: &Self::Context,
-        res: &Result<Res, Error>,
-    ) -> Result<(), sqlx::Error> {
+    async fn ack(&mut self, ctx: &Self::Context, res: &Response<Res>) -> Result<(), sqlx::Error> {
         self.ack_notify
-            .notify((
-                ctx.clone(),
-                res.as_ref()
-                    .map_err(|c| c.clone())
-                    .and_then(|r| C::encode(r).map_err(|e| Error::SourceError(Arc::new(e.into())))),
-            ))
+            .notify((ctx.clone(), res.map(|res| C::encode(res).unwrap())))
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::BrokenPipe, e)))?;
 
         Ok(())
@@ -536,7 +526,6 @@ mod tests {
     use crate::sql_storage_tests;
 
     use super::*;
-    use apalis_core::task::attempt::Attempt;
 
     use apalis_core::test_utils::DummyService;
     use email_service::Email;
@@ -587,13 +576,11 @@ mod tests {
     async fn consume_one(
         storage: &mut MysqlStorage<Email>,
         worker_id: &WorkerId,
-    ) -> Request<Email> {
-        let mut stream = storage.clone().stream_jobs(
-            worker_id,
-            std::time::Duration::from_secs(10),
-            1,
-            &Config::default(),
-        );
+    ) -> Request<Email, SqlContext> {
+        let mut stream =
+            storage
+                .clone()
+                .stream_jobs(worker_id, std::time::Duration::from_secs(10), 1);
         stream
             .next()
             .await
@@ -633,7 +620,10 @@ mod tests {
         storage.push(email).await.expect("failed to push a job");
     }
 
-    async fn get_job(storage: &mut MysqlStorage<Email>, job_id: &TaskId) -> Request<Email> {
+    async fn get_job(
+        storage: &mut MysqlStorage<Email>,
+        job_id: &TaskId,
+    ) -> Request<Email, SqlContext> {
         // add a slight delay to allow background actions like ack to complete
         apalis_core::sleep(Duration::from_secs(1)).await;
         storage
@@ -651,7 +641,7 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         // TODO: Fix assertions
         assert_eq!(*ctx.status(), State::Running);
         assert_eq!(*ctx.lock_by(), Some(worker_id.clone()));
@@ -668,8 +658,7 @@ mod tests {
 
         let job = consume_one(&mut storage, &worker_id).await;
 
-        let ctx = job.get::<SqlContext>().unwrap();
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
 
         storage
             .kill(&worker_id, job_id)
@@ -677,7 +666,7 @@ mod tests {
             .expect("failed to kill job");
 
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         // TODO: Fix assertions
         assert_eq!(*ctx.status(), State::Killed);
         assert!(ctx.done_at().is_some());
@@ -705,15 +694,19 @@ mod tests {
 
         // fetch job
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
 
         assert_eq!(*ctx.status(), State::Running);
 
         storage.reenqueue_orphaned(300).await.unwrap();
 
         // then, the job status has changed to Pending
-        let job = storage.fetch_by_id(ctx.id()).await.unwrap().unwrap();
-        let context = job.get::<SqlContext>().unwrap();
+        let job = storage
+            .fetch_by_id(&job.parts.task_id)
+            .await
+            .unwrap()
+            .unwrap();
+        let context = job.parts.context;
         assert_eq!(*context.status(), State::Pending);
         assert!(context.lock_by().is_none());
         assert!(context.lock_at().is_none());
@@ -742,7 +735,7 @@ mod tests {
 
         // fetch job
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = &job.parts.context;
 
         assert_eq!(*ctx.status(), State::Running);
 
@@ -750,8 +743,12 @@ mod tests {
         storage.reenqueue_orphaned(300).await.unwrap();
 
         // then, the job status is not changed
-        let job = storage.fetch_by_id(ctx.id()).await.unwrap().unwrap();
-        let context = job.get::<SqlContext>().unwrap();
+        let job = storage
+            .fetch_by_id(&job.parts.task_id)
+            .await
+            .unwrap()
+            .unwrap();
+        let context = job.parts.context;
         // TODO: Fix assertions
         assert_eq!(*context.status(), State::Running);
         assert_eq!(*context.lock_by(), Some(worker_id.clone()));
diff --git a/packages/apalis-sql/src/postgres.rs b/packages/apalis-sql/src/postgres.rs
index 53b2bcb..72cb1ab 100644
--- a/packages/apalis-sql/src/postgres.rs
+++ b/packages/apalis-sql/src/postgres.rs
@@ -47,7 +47,8 @@ use apalis_core::notify::Notify;
 use apalis_core::poller::controller::Controller;
 use apalis_core::poller::stream::BackendStream;
 use apalis_core::poller::Poller;
-use apalis_core::request::{Request, RequestStream};
+use apalis_core::request::{Parts, Request, RequestStream};
+use apalis_core::response::Response;
 use apalis_core::storage::Storage;
 use apalis_core::task::namespace::Namespace;
 use apalis_core::task::task_id::TaskId;
@@ -86,7 +87,7 @@ where
     codec: PhantomData<C>,
     config: Config,
     controller: Controller,
-    ack_notify: Notify<(SqlContext, Result<C::Compact, Error>)>,
+    ack_notify: Notify<(SqlContext, Response<C::Compact>)>,
     subscription: Option<PgSubscription>,
 }
 
@@ -117,14 +118,14 @@ impl<T, C: Codec> fmt::Debug for PostgresStorage<T, C> {
     }
 }
 
-impl<T, C, Res> Backend<Request<T>, Res> for PostgresStorage<T, C>
+impl<T, C, Res> Backend<Request<T, SqlContext>, Res> for PostgresStorage<T, C>
 where
     T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static,
     C: Codec<Compact = serde_json::Value> + Send + 'static,
 {
-    type Stream = BackendStream<RequestStream<Request<T>>>;
+    type Stream = BackendStream<RequestStream<Request<T, SqlContext>>>;
 
-    type Layer = AckLayer<PostgresStorage<T, C>, T, Res>;
+    type Layer = AckLayer<PostgresStorage<T, C>, T, SqlContext, Res>;
 
     fn poll<Svc>(mut self, worker: WorkerId) -> Poller<Self::Stream, Self::Layer> {
         let layer = AckLayer::new(self.clone());
@@ -150,7 +151,7 @@ where
             >(
                 storage: &mut PostgresStorage<T, C>,
                 worker: &WorkerId,
-                tx: &mut mpsc::Sender<Result<Option<Request<T>>, Error>>,
+                tx: &mut mpsc::Sender<Result<Option<Request<T, SqlContext>>, Error>>,
             ) -> Result<(), Error> {
                 let res = storage
                     .fetch_next(worker)
@@ -181,7 +182,7 @@ where
                     ids = ack_stream.next() => {
                         if let Some(ids) = ids {
                             let ack_ids: Vec<(String, String, String, String, u64)> = ids.iter().map(|(ctx, res)| {
-                                (ctx.id().to_string(), ctx.lock_by().clone().unwrap().to_string(), serde_json::to_string(&res.as_ref().map_err(|e| e.to_string())).unwrap(), calculate_status(res).to_string(), (ctx.attempts().current() + 1) as u64 )
+                                (res.task_id.to_string(), ctx.lock_by().clone().unwrap().to_string(), serde_json::to_string(&res.inner.as_ref().map_err(|e| e.to_string())).unwrap(), calculate_status(&res.inner).to_string(), (res.attempt.current() + 1) as u64 )
                             }).collect();
                             let query =
                                 "UPDATE apalis.jobs
@@ -369,7 +370,10 @@ where
     T: DeserializeOwned + Send + Unpin + 'static,
     C: Codec<Compact = serde_json::Value>,
 {
-    async fn fetch_next(&mut self, worker_id: &WorkerId) -> Result<Vec<Request<T>>, sqlx::Error> {
+    async fn fetch_next(
+        &mut self,
+        worker_id: &WorkerId,
+    ) -> Result<Vec<Request<T, SqlContext>>, sqlx::Error> {
         let config = &self.config;
         let job_type = &config.namespace;
         let fetch_query = "Select * from apalis.get_jobs($1, $2, $3);";
@@ -386,13 +390,12 @@ where
         let jobs: Vec<_> = jobs
             .into_iter()
             .map(|job| {
-                let (req, ctx) = job.into_tuple();
+                let (req, parts) = job.req.take_parts();
                 let req = C::decode(req)
                     .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))
                     .unwrap();
-                let req = SqlRequest::new(req, ctx);
-                let mut req: Request<T> = req.into();
-                req.insert(Namespace(self.config.namespace.clone()));
+                let mut req = Request::new_with_parts(req, parts);
+                req.parts.namespace = Some(Namespace(self.config.namespace.clone()));
                 req
             })
             .collect();
@@ -400,16 +403,16 @@ where
     }
 }
 
-impl<T, C> Storage for PostgresStorage<T, C>
+impl<Req, C> Storage for PostgresStorage<Req, C>
 where
-    T: Serialize + DeserializeOwned + Send + 'static + Unpin + Sync,
+    Req: Serialize + DeserializeOwned + Send + 'static + Unpin + Sync,
     C: Codec<Compact = Value> + Send + 'static,
 {
-    type Job = T;
+    type Job = Req;
 
     type Error = sqlx::Error;
 
-    type Identifier = TaskId;
+    type Context = SqlContext;
 
     /// Push a job to Postgres [Storage]
     ///
@@ -418,46 +421,52 @@ where
     /// ```sql
     /// Select apalis.push_job(job_type::text, job::json);
     /// ```
-    async fn push(&mut self, job: Self::Job) -> Result<TaskId, sqlx::Error> {
-        let id = TaskId::new();
+    async fn push_request(
+        &mut self,
+        req: Request<Self::Job, SqlContext>,
+    ) -> Result<Parts<SqlContext>, sqlx::Error> {
         let query = "INSERT INTO apalis.jobs VALUES ($1, $2, $3, 'Pending', 0, 25, NOW() , NULL, NULL, NULL, NULL)";
 
-        let job = C::encode(&job)
+        let args = C::encode(&req.args)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
-            .bind(job)
-            .bind(id.to_string())
+            .bind(args)
+            .bind(&req.parts.task_id.to_string())
             .bind(&job_type)
             .execute(&self.pool)
             .await?;
-        Ok(id)
+        Ok(req.parts)
     }
 
-    async fn schedule(&mut self, job: Self::Job, on: Timestamp) -> Result<TaskId, sqlx::Error> {
+    async fn schedule_request(
+        &mut self,
+        req: Request<Self::Job, SqlContext>,
+        on: Timestamp,
+    ) -> Result<Parts<Self::Context>, sqlx::Error> {
         let query =
             "INSERT INTO apalis.jobs VALUES ($1, $2, $3, 'Pending', 0, 25, $4, NULL, NULL, NULL, NULL)";
-
-        let id = TaskId::new();
+        let task_id = req.parts.task_id.to_string();
+        let parts = req.parts;
         let on = DateTime::from_timestamp(on, 0);
-        let job = C::encode(&job)
+        let job = C::encode(&req.args)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidInput, e)))?;
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
             .bind(job)
-            .bind(id.to_string())
+            .bind(task_id)
             .bind(job_type)
             .bind(on)
             .execute(&self.pool)
             .await?;
-        Ok(id)
+        Ok(parts)
     }
 
     async fn fetch_by_id(
         &mut self,
         job_id: &TaskId,
-    ) -> Result<Option<Request<Self::Job>>, sqlx::Error> {
-        let fetch_query = "SELECT * FROM apalis.jobs WHERE id = $1";
+    ) -> Result<Option<Request<Self::Job, SqlContext>>, sqlx::Error> {
+        let fetch_query = "SELECT * FROM apalis.jobs WHERE id = $1 LIMIT 1";
         let res: Option<SqlRequest<serde_json::Value>> = sqlx::query_as(fetch_query)
             .bind(job_id.to_string())
             .fetch_optional(&self.pool)
@@ -466,12 +475,12 @@ where
         match res {
             None => Ok(None),
             Some(job) => Ok(Some({
-                let (req, ctx) = job.into_tuple();
-                let req = C::decode(req)
+                let (req, parts) = job.req.take_parts();
+                let args = C::decode(req)
                     .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
-                let req = SqlRequest::new(req, ctx);
-                let mut req: Request<T> = req.into();
-                req.insert(Namespace(self.config.namespace.clone()));
+
+                let mut req: Request<Req, SqlContext> = Request::new_with_parts(args, parts);
+                req.parts.namespace = Some(Namespace(self.config.namespace.clone()));
                 req
             })),
         }
@@ -483,14 +492,12 @@ where
         record.try_get("count")
     }
 
-    async fn reschedule(&mut self, job: Request<T>, wait: Duration) -> Result<(), sqlx::Error> {
-        let ctx = job
-            .get::<SqlContext>()
-            .ok_or(sqlx::Error::Io(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "Missing SqlContext",
-            )))?;
-        let job_id = ctx.id();
+    async fn reschedule(
+        &mut self,
+        job: Request<Req, SqlContext>,
+        wait: Duration,
+    ) -> Result<(), sqlx::Error> {
+        let job_id = job.parts.task_id;
         let on = Utc::now() + wait;
         let mut tx = self.pool.acquire().await?;
         let query =
@@ -504,17 +511,13 @@ where
         Ok(())
     }
 
-    async fn update(&mut self, job: Request<Self::Job>) -> Result<(), sqlx::Error> {
-        let ctx = job
-            .get::<SqlContext>()
-            .ok_or(sqlx::Error::Io(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "Missing SqlContext",
-            )))?;
-        let job_id = ctx.id();
+    async fn update(&mut self, job: Request<Self::Job, SqlContext>) -> Result<(), sqlx::Error> {
+        let ctx = job.parts.context;
+        let job_id = job.parts.task_id;
         let status = ctx.status().to_string();
-        let attempts: i32 = ctx
-            .attempts()
+        let attempts: i32 = job
+            .parts
+            .attempt
             .current()
             .try_into()
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
@@ -553,29 +556,19 @@ where
 impl<T, Res, C> Ack<T, Res> for PostgresStorage<T, C>
 where
     T: Sync + Send,
-    Res: Serialize + Sync,
+    Res: Serialize + Sync + Clone,
     C: Codec<Compact = Value> + Send,
 {
     type Context = SqlContext;
     type AckError = sqlx::Error;
-    async fn ack(
-        &mut self,
-        ctx: &Self::Context,
-        res: &Result<Res, apalis_core::error::Error>,
-    ) -> Result<(), sqlx::Error> {
+    async fn ack(&mut self, ctx: &Self::Context, res: &Response<Res>) -> Result<(), sqlx::Error> {
+        let res = res.clone().map(|r| {
+            C::encode(r)
+                .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::Interrupted, e)))
+                .unwrap()
+        });
         self.ack_notify
-            .notify((
-                ctx.clone(),
-                res.as_ref()
-                    .map(|r| {
-                        C::encode(r)
-                            .map_err(|e| {
-                                sqlx::Error::Io(io::Error::new(io::ErrorKind::Interrupted, e))
-                            })
-                            .unwrap()
-                    })
-                    .map_err(|e| e.clone()),
-            ))
+            .notify((ctx.clone(), res))
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::Interrupted, e)))?;
 
         Ok(())
@@ -662,7 +655,8 @@ mod tests {
         // (different runtimes are created for each test),
         // we don't share the storage and tests must be run sequentially.
         PostgresStorage::setup(&pool).await.unwrap();
-        let mut storage = PostgresStorage::new(pool);
+        let config = Config::new("apalis-ci-tests").set_buffer_size(1);
+        let mut storage = PostgresStorage::new_with_config(pool, config);
         cleanup(&mut storage, &WorkerId::new("test-worker")).await;
         storage
     }
@@ -703,7 +697,7 @@ mod tests {
     async fn consume_one(
         storage: &mut PostgresStorage<Email>,
         worker_id: &WorkerId,
-    ) -> Request<Email> {
+    ) -> Request<Email, SqlContext> {
         let req = storage.fetch_next(worker_id).await;
         req.unwrap()[0].clone()
     }
@@ -729,7 +723,10 @@ mod tests {
         storage.push(email).await.expect("failed to push a job");
     }
 
-    async fn get_job(storage: &mut PostgresStorage<Email>, job_id: &TaskId) -> Request<Email> {
+    async fn get_job(
+        storage: &mut PostgresStorage<Email>,
+        job_id: &TaskId,
+    ) -> Request<Email, SqlContext> {
         // add a slight delay to allow background actions like ack to complete
         apalis_core::sleep(Duration::from_secs(2)).await;
         storage
@@ -747,11 +744,11 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
+
         // Refresh our job
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         assert_eq!(*ctx.status(), State::Running);
         assert_eq!(*ctx.lock_by(), Some(worker_id.clone()));
         assert!(ctx.lock_at().is_some());
@@ -766,8 +763,7 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
 
         storage
             .kill(&worker_id, job_id)
@@ -775,7 +771,7 @@ mod tests {
             .expect("failed to kill job");
 
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         assert_eq!(*ctx.status(), State::Killed);
         assert!(ctx.done_at().is_some());
     }
@@ -793,10 +789,9 @@ mod tests {
             .reenqueue_orphaned(5)
             .await
             .expect("failed to heartbeat");
-        let ctx = job.get::<SqlContext>().unwrap();
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
 
         assert_eq!(*ctx.status(), State::Pending);
         assert!(ctx.done_at().is_none());
@@ -816,7 +811,7 @@ mod tests {
         let worker_id = register_worker_at(&mut storage, four_minutes_ago.timestamp()).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = &job.parts.context;
 
         assert_eq!(*ctx.status(), State::Running);
         storage
@@ -824,9 +819,9 @@ mod tests {
             .await
             .expect("failed to heartbeat");
 
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
 
         assert_eq!(*ctx.status(), State::Running);
         assert_eq!(*ctx.lock_by(), Some(worker_id.clone()));
diff --git a/packages/apalis-sql/src/sqlite.rs b/packages/apalis-sql/src/sqlite.rs
index 27dcb2a..c4cdb7c 100644
--- a/packages/apalis-sql/src/sqlite.rs
+++ b/packages/apalis-sql/src/sqlite.rs
@@ -6,7 +6,8 @@ use apalis_core::layers::{Ack, AckLayer};
 use apalis_core::poller::controller::Controller;
 use apalis_core::poller::stream::BackendStream;
 use apalis_core::poller::Poller;
-use apalis_core::request::{Request, RequestStream};
+use apalis_core::request::{Parts, Request, RequestStream};
+use apalis_core::response::Response;
 use apalis_core::storage::Storage;
 use apalis_core::task::namespace::Namespace;
 use apalis_core::task::task_id::TaskId;
@@ -178,10 +179,11 @@ where
         worker_id: &WorkerId,
         interval: Duration,
         buffer_size: usize,
-    ) -> impl Stream<Item = Result<Option<Request<T>>, sqlx::Error>> {
+    ) -> impl Stream<Item = Result<Option<Request<T, SqlContext>>, sqlx::Error>> {
         let pool = self.pool.clone();
         let worker_id = worker_id.clone();
         let config = self.config.clone();
+        let namespace = Namespace(self.config.namespace.clone());
         try_stream! {
             loop {
                 let tx = pool.clone();
@@ -199,14 +201,13 @@ where
                 for id in ids {
                     let res = fetch_next(&pool, &worker_id, id.0, &config).await?;
                     yield match res {
-                        None => None::<Request<T>>,
+                        None => None::<Request<T, SqlContext>>,
                         Some(job) => {
-                            let (req, ctx) = job.into_tuple();
-                            let req = C::decode(req)
+                            let (req, parts) = job.req.take_parts();
+                            let args = C::decode(req)
                                 .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
-                            let req = SqlRequest::new(req, ctx);
-                            let mut req: Request<T> = req.into();
-                            req.insert(Namespace(config.namespace.clone()));
+                            let mut req = Request::new_with_parts(args, parts);
+                            req.parts.namespace = Some(namespace.clone());
                             Some(req)
                         }
                     }
@@ -226,30 +227,35 @@ where
 
     type Error = sqlx::Error;
 
-    type Identifier = TaskId;
+    type Context = SqlContext;
 
-    async fn push(&mut self, job: Self::Job) -> Result<TaskId, Self::Error> {
-        let id = TaskId::new();
+    async fn push_request(
+        &mut self,
+        job: Request<Self::Job, SqlContext>,
+    ) -> Result<Parts<SqlContext>, Self::Error> {
         let query = "INSERT INTO Jobs VALUES (?1, ?2, ?3, 'Pending', 0, 25, strftime('%s','now'), NULL, NULL, NULL, NULL)";
-
-        let job = C::encode(&job)
+        let (task, parts) = job.take_parts();
+        let raw = C::encode(&task)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
-            .bind(job)
-            .bind(id.to_string())
+            .bind(raw)
+            .bind(&parts.task_id.to_string())
             .bind(job_type.to_string())
             .execute(&self.pool)
             .await?;
-        Ok(id)
+        Ok(parts)
     }
 
-    async fn schedule(&mut self, job: Self::Job, on: i64) -> Result<TaskId, Self::Error> {
+    async fn schedule_request(
+        &mut self,
+        req: Request<Self::Job, SqlContext>,
+        on: i64,
+    ) -> Result<Parts<SqlContext>, Self::Error> {
         let query =
             "INSERT INTO Jobs VALUES (?1, ?2, ?3, 'Pending', 0, 25, ?4, NULL, NULL, NULL, NULL)";
-
-        let id = TaskId::new();
-        let job = C::encode(&job)
+        let id = &req.parts.task_id;
+        let job = C::encode(&req.args)
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
         let job_type = self.config.namespace.clone();
         sqlx::query(query)
@@ -259,13 +265,13 @@ where
             .bind(on)
             .execute(&self.pool)
             .await?;
-        Ok(id)
+        Ok(req.parts)
     }
 
     async fn fetch_by_id(
         &mut self,
         job_id: &TaskId,
-    ) -> Result<Option<Request<Self::Job>>, Self::Error> {
+    ) -> Result<Option<Request<Self::Job, SqlContext>>, Self::Error> {
         let fetch_query = "SELECT * FROM Jobs WHERE id = ?1";
         let res: Option<SqlRequest<String>> = sqlx::query_as(fetch_query)
             .bind(job_id.to_string())
@@ -274,12 +280,12 @@ where
         match res {
             None => Ok(None),
             Some(job) => Ok(Some({
-                let (req, ctx) = job.into_tuple();
-                let req = C::decode(req)
+                let (req, parts) = job.req.take_parts();
+                let args = C::decode(req)
                     .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
-                let req = SqlRequest::new(req, ctx);
-                let mut req: Request<T> = req.into();
-                req.insert(Namespace(self.config.namespace.clone()));
+
+                let mut req: Request<T, SqlContext> = Request::new_with_parts(args, parts);
+                req.parts.namespace = Some(Namespace(self.config.namespace.clone()));
                 req
             })),
         }
@@ -291,11 +297,12 @@ where
         record.try_get("count")
     }
 
-    async fn reschedule(&mut self, job: Request<T>, wait: Duration) -> Result<(), Self::Error> {
-        let task_id = job.get::<TaskId>().ok_or(sqlx::Error::Io(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Missing TaskId",
-        )))?;
+    async fn reschedule(
+        &mut self,
+        job: Request<T, SqlContext>,
+        wait: Duration,
+    ) -> Result<(), Self::Error> {
+        let task_id = job.parts.task_id;
 
         let wait: i64 = wait
             .as_secs()
@@ -316,20 +323,15 @@ where
         Ok(())
     }
 
-    async fn update(&mut self, job: Request<Self::Job>) -> Result<(), Self::Error> {
-        let ctx = job
-            .get::<SqlContext>()
-            .ok_or(sqlx::Error::Io(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "Missing SqlContext",
-            )))?;
+    async fn update(&mut self, job: Request<Self::Job, SqlContext>) -> Result<(), Self::Error> {
+        let ctx = job.parts.context;
         let status = ctx.status().to_string();
-        let attempts = ctx.attempts();
+        let attempts = job.parts.attempt;
         let done_at = *ctx.done_at();
         let lock_by = ctx.lock_by().clone();
         let lock_at = *ctx.lock_at();
         let last_error = ctx.last_error().clone();
-        let job_id = ctx.id();
+        let job_id = job.parts.task_id;
         let mut tx = self.pool.acquire().await?;
         let query =
                 "UPDATE Jobs SET status = ?1, attempts = ?2, done_at = ?3, lock_by = ?4, lock_at = ?5, last_error = ?6 WHERE id = ?7";
@@ -439,11 +441,11 @@ impl<T> SqliteStorage<T> {
     }
 }
 
-impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static, Res> Backend<Request<T>, Res>
-    for SqliteStorage<T>
+impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static, Res>
+    Backend<Request<T, SqlContext>, Res> for SqliteStorage<T>
 {
-    type Stream = BackendStream<RequestStream<Request<T>>>;
-    type Layer = AckLayer<SqliteStorage<T>, T, Res>;
+    type Stream = BackendStream<RequestStream<Request<T, SqlContext>>>;
+    type Layer = AckLayer<SqliteStorage<T>, T, SqlContext, Res>;
 
     fn poll<Svc>(mut self, worker: WorkerId) -> Poller<Self::Stream, Self::Layer> {
         let layer = AckLayer::new(self.clone());
@@ -470,22 +472,18 @@ impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static, Res> Backe
 impl<T: Sync + Send, Res: Serialize + Sync> Ack<T, Res> for SqliteStorage<T> {
     type Context = SqlContext;
     type AckError = sqlx::Error;
-    async fn ack(
-        &mut self,
-        ctx: &Self::Context,
-        res: &Result<Res, apalis_core::error::Error>,
-    ) -> Result<(), sqlx::Error> {
+    async fn ack(&mut self, ctx: &Self::Context, res: &Response<Res>) -> Result<(), sqlx::Error> {
         let pool = self.pool.clone();
         let query =
                 "UPDATE Jobs SET status = ?4, done_at = strftime('%s','now'), last_error = ?3, attempts =?5 WHERE id = ?1 AND lock_by = ?2";
-        let result = serde_json::to_string(&res.as_ref().map_err(|r| r.to_string()))
+        let result = serde_json::to_string(&res.inner.as_ref().map_err(|r| r.to_string()))
             .map_err(|e| sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, e)))?;
         sqlx::query(query)
-            .bind(ctx.id().to_string())
+            .bind(res.task_id.to_string())
             .bind(ctx.lock_by().as_ref().unwrap().to_string())
             .bind(result)
-            .bind(calculate_status(res).to_string())
-            .bind(ctx.attempts().current() as i64 + 1)
+            .bind(calculate_status(&res.inner).to_string())
+            .bind(res.attempt.current() as i64 + 1)
             .execute(&pool)
             .await?;
         Ok(())
@@ -544,7 +542,7 @@ mod tests {
     async fn consume_one(
         storage: &mut SqliteStorage<Email>,
         worker_id: &WorkerId,
-    ) -> Request<Email> {
+    ) -> Request<Email, SqlContext> {
         let mut stream = storage
             .stream_jobs(worker_id, std::time::Duration::from_secs(10), 1)
             .boxed();
@@ -574,7 +572,10 @@ mod tests {
         storage.push(email).await.expect("failed to push a job");
     }
 
-    async fn get_job(storage: &mut SqliteStorage<Email>, job_id: &TaskId) -> Request<Email> {
+    async fn get_job(
+        storage: &mut SqliteStorage<Email>,
+        job_id: &TaskId,
+    ) -> Request<Email, SqlContext> {
         storage
             .fetch_by_id(job_id)
             .await
@@ -592,7 +593,7 @@ mod tests {
         assert_eq!(len, 1);
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         assert_eq!(*ctx.status(), State::Running);
         assert_eq!(*ctx.lock_by(), Some(worker_id.clone()));
         assert!(ctx.lock_at().is_some());
@@ -605,17 +606,19 @@ mod tests {
 
         push_email(&mut storage, example_good_email()).await;
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>();
-        assert!(ctx.is_some());
-        let job_id = ctx.unwrap().id();
-
+        let job_id = &job.parts.task_id;
+        let ctx = &job.parts.context;
+        let res = 1usize;
         storage
-            .ack(ctx.as_ref().unwrap(), &Ok(()))
+            .ack(
+                ctx,
+                &Response::success(res, job_id.clone(), job.parts.attempt.clone()),
+            )
             .await
             .expect("failed to acknowledge the job");
 
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         assert_eq!(*ctx.status(), State::Done);
         assert!(ctx.done_at().is_some());
     }
@@ -629,8 +632,7 @@ mod tests {
         let worker_id = register_worker(&mut storage).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
-        let job_id = ctx.id();
+        let job_id = &job.parts.task_id;
 
         storage
             .kill(&worker_id, job_id)
@@ -638,7 +640,7 @@ mod tests {
             .expect("failed to kill job");
 
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = job.parts.context;
         assert_eq!(*ctx.status(), State::Killed);
         assert!(ctx.done_at().is_some());
     }
@@ -654,15 +656,13 @@ mod tests {
         let worker_id = register_worker_at(&mut storage, six_minutes_ago.timestamp()).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let job_id = &job.parts.task_id;
         storage
             .reenqueue_orphaned(six_minutes_ago.timestamp())
             .await
             .expect("failed to heartbeat");
-
-        let job_id = ctx.id();
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = &job.parts.context;
         assert_eq!(*ctx.status(), State::Running);
         assert!(ctx.done_at().is_none());
         assert!(ctx.lock_by().is_some());
@@ -680,15 +680,14 @@ mod tests {
         let worker_id = register_worker_at(&mut storage, four_minutes_ago.timestamp()).await;
 
         let job = consume_one(&mut storage, &worker_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let job_id = &job.parts.task_id;
         storage
             .reenqueue_orphaned(four_minutes_ago.timestamp())
             .await
             .expect("failed to heartbeat");
 
-        let job_id = ctx.id();
         let job = get_job(&mut storage, job_id).await;
-        let ctx = job.get::<SqlContext>().unwrap();
+        let ctx = &job.parts.context;
         assert_eq!(*ctx.status(), State::Running);
         assert_eq!(*ctx.lock_by(), Some(worker_id));
     }
diff --git a/src/layers/catch_panic/mod.rs b/src/layers/catch_panic/mod.rs
index f4b39d7..2f5bdac 100644
--- a/src/layers/catch_panic/mod.rs
+++ b/src/layers/catch_panic/mod.rs
@@ -1,3 +1,4 @@
+use std::any::Any;
 use std::fmt;
 use std::future::Future;
 use std::panic::{catch_unwind, AssertUnwindSafe};
@@ -12,59 +13,77 @@ use tower::Service;
 
 /// Apalis Layer that catches panics in the service.
 #[derive(Clone, Debug)]
-pub struct CatchPanicLayer;
+pub struct CatchPanicLayer<F> {
+    on_panic: F,
+}
 
-impl CatchPanicLayer {
-    /// Creates a new `CatchPanicLayer`.
+impl CatchPanicLayer<fn(Box<dyn Any + Send>) -> Error> {
+    /// Creates a new `CatchPanicLayer` with a default panic handler.
     pub fn new() -> Self {
-        CatchPanicLayer
+        CatchPanicLayer {
+            on_panic: default_handler,
+        }
     }
 }
 
-impl Default for CatchPanicLayer {
-    fn default() -> Self {
-        Self::new()
+impl<F> CatchPanicLayer<F>
+where
+    F: FnMut(Box<dyn Any + Send>) -> Error + Clone,
+{
+    /// Creates a new `CatchPanicLayer` with a custom panic handler.
+    pub fn with_panic_handler(on_panic: F) -> Self {
+        CatchPanicLayer { on_panic }
     }
 }
 
-impl<S> Layer<S> for CatchPanicLayer {
-    type Service = CatchPanicService<S>;
+impl<S, F> Layer<S> for CatchPanicLayer<F>
+where
+    F: FnMut(Box<dyn Any + Send>) -> Error + Clone,
+{
+    type Service = CatchPanicService<S, F>;
 
     fn layer(&self, service: S) -> Self::Service {
-        CatchPanicService { service }
+        CatchPanicService {
+            service,
+            on_panic: self.on_panic.clone(),
+        }
     }
 }
 
 /// Apalis Service that catches panics.
 #[derive(Clone, Debug)]
-pub struct CatchPanicService<S> {
+pub struct CatchPanicService<S, F> {
     service: S,
+    on_panic: F,
 }
 
-impl<S, J, Res> Service<Request<J>> for CatchPanicService<S>
+impl<S, Req, Res, Ctx, F> Service<Request<Req, Ctx>> for CatchPanicService<S, F>
 where
-    S: Service<Request<J>, Response = Res, Error = Error>,
+    S: Service<Request<Req, Ctx>, Response = Res, Error = Error>,
+    F: FnMut(Box<dyn Any + Send>) -> Error + Clone,
 {
     type Response = S::Response;
     type Error = S::Error;
-    type Future = CatchPanicFuture<S::Future>;
+    type Future = CatchPanicFuture<S::Future, F>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, request: Request<J>) -> Self::Future {
+    fn call(&mut self, request: Request<Req, Ctx>) -> Self::Future {
         CatchPanicFuture {
             future: self.service.call(request),
+            on_panic: self.on_panic.clone(),
         }
     }
 }
 
 pin_project_lite::pin_project! {
     /// A wrapper that catches panics during execution
-    pub struct CatchPanicFuture<F> {
+    pub struct CatchPanicFuture<Fut, F> {
         #[pin]
-        future: F,
+        future: Fut,
+        on_panic: F,
     }
 }
 
@@ -80,9 +99,10 @@ impl fmt::Display for PanicError {
     }
 }
 
-impl<F, Res> Future for CatchPanicFuture<F>
+impl<Fut, Res, F> Future for CatchPanicFuture<Fut, F>
 where
-    F: Future<Output = Result<Res, Error>>,
+    Fut: Future<Output = Result<Res, Error>>,
+    F: FnMut(Box<dyn Any + Send>) -> Error,
 {
     type Output = Result<Res, Error>;
 
@@ -91,24 +111,24 @@ where
 
         match catch_unwind(AssertUnwindSafe(|| this.future.poll(cx))) {
             Ok(res) => res,
-            Err(e) => {
-                let panic_info = if let Some(s) = e.downcast_ref::<&str>() {
-                    s.to_string()
-                } else if let Some(s) = e.downcast_ref::<String>() {
-                    s.clone()
-                } else {
-                    "Unknown panic".to_string()
-                };
-                // apalis assumes service functions are pure
-                // therefore a panic should ideally abort
-                Poll::Ready(Err(Error::Abort(Arc::new(Box::new(PanicError(
-                    panic_info,
-                ))))))
-            }
+            Err(e) => Poll::Ready(Err((this.on_panic)(e))),
         }
     }
 }
 
+fn default_handler(e: Box<dyn Any + Send>) -> Error {
+    let panic_info = if let Some(s) = e.downcast_ref::<&str>() {
+        s.to_string()
+    } else if let Some(s) = e.downcast_ref::<String>() {
+        s.clone()
+    } else {
+        "Unknown panic".to_string()
+    };
+    // apalis assumes service functions are pure
+    // therefore a panic should ideally abort
+    Error::Abort(Arc::new(Box::new(PanicError(panic_info))))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -122,7 +142,7 @@ mod tests {
     #[derive(Clone)]
     struct TestService;
 
-    impl Service<Request<TestJob>> for TestService {
+    impl Service<Request<TestJob, ()>> for TestService {
         type Response = usize;
         type Error = Error;
         type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -131,7 +151,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call(&mut self, _req: Request<TestJob>) -> Self::Future {
+        fn call(&mut self, _req: Request<TestJob, ()>) -> Self::Future {
             Box::pin(async { Ok(42) })
         }
     }
@@ -151,7 +171,7 @@ mod tests {
     async fn test_catch_panic_layer_panics() {
         struct PanicService;
 
-        impl Service<Request<TestJob>> for PanicService {
+        impl Service<Request<TestJob, ()>> for PanicService {
             type Response = usize;
             type Error = Error;
             type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -160,7 +180,7 @@ mod tests {
                 Poll::Ready(Ok(()))
             }
 
-            fn call(&mut self, _req: Request<TestJob>) -> Self::Future {
+            fn call(&mut self, _req: Request<TestJob, ()>) -> Self::Future {
                 Box::pin(async { None.unwrap() })
             }
         }
@@ -174,8 +194,8 @@ mod tests {
         assert!(response.is_err());
 
         assert_eq!(
-            response.unwrap_err().to_string()[0..87],
-            *"FailedError: PanicError: called `Option::unwrap()` on a `None` value, Backtrace:    0: "
+            response.unwrap_err().to_string(),
+            *"AbortError: PanicError: called `Option::unwrap()` on a `None` value"
         );
     }
 }
diff --git a/src/layers/mod.rs b/src/layers/mod.rs
index 0e28e94..9329444 100644
--- a/src/layers/mod.rs
+++ b/src/layers/mod.rs
@@ -32,3 +32,5 @@ pub use tower::timeout::TimeoutLayer;
 #[cfg(feature = "catch-panic")]
 #[cfg_attr(docsrs, doc(cfg(feature = "catch-panic")))]
 pub mod catch_panic;
+
+pub use apalis_core::error::ErrorHandlingLayer;
diff --git a/src/layers/prometheus/mod.rs b/src/layers/prometheus/mod.rs
index 66923d1..99507b5 100644
--- a/src/layers/prometheus/mod.rs
+++ b/src/layers/prometheus/mod.rs
@@ -4,7 +4,7 @@ use std::{
     time::Instant,
 };
 
-use apalis_core::{error::Error, request::Request, task::namespace::Namespace};
+use apalis_core::{error::Error, request::Request};
 use futures::Future;
 use pin_project_lite::pin_project;
 use tower::{Layer, Service};
@@ -27,25 +27,30 @@ pub struct PrometheusService<S> {
     service: S,
 }
 
-impl<S, J, F, Res> Service<Request<J>> for PrometheusService<S>
+impl<Svc, Fut, Req, Ctx, Res> Service<Request<Req, Ctx>> for PrometheusService<Svc>
 where
-    S: Service<Request<J>, Response = Res, Error = Error, Future = F>,
-    F: Future<Output = Result<Res, Error>> + 'static,
+    Svc: Service<Request<Req, Ctx>, Response = Res, Error = Error, Future = Fut>,
+    Fut: Future<Output = Result<Res, Error>> + 'static,
 {
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = ResponseFuture<F>;
+    type Response = Svc::Response;
+    type Error = Svc::Error;
+    type Future = ResponseFuture<Fut>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, request: Request<J>) -> Self::Future {
+    fn call(&mut self, request: Request<Req, Ctx>) -> Self::Future {
         let start = Instant::now();
-        let namespace = request.get::<Namespace>().unwrap().to_string();
+        let namespace = request
+            .parts
+            .namespace
+            .as_ref()
+            .map(|ns| ns.0.to_string())
+            .unwrap_or(std::any::type_name::<Svc>().to_string());
 
         let req = self.service.call(request);
-        let job_type = std::any::type_name::<J>().to_string();
+        let job_type = std::any::type_name::<Req>().to_string();
 
         ResponseFuture {
             inner: req,
diff --git a/src/layers/retry/mod.rs b/src/layers/retry/mod.rs
index 7d455c0..3dbbafd 100644
--- a/src/layers/retry/mod.rs
+++ b/src/layers/retry/mod.rs
@@ -1,15 +1,13 @@
 use futures::future;
 use tower::retry::Policy;
 
+use apalis_core::{error::Error, request::Request};
 /// Re-export from [`RetryLayer`]
 ///
 /// [`RetryLayer`]: tower::retry::RetryLayer
 pub use tower::retry::RetryLayer;
 
-use apalis_core::task::attempt::Attempt;
-use apalis_core::{error::Error, request::Request};
-
-type Req<T> = Request<T>;
+type Req<T, Ctx> = Request<T, Ctx>;
 type Err = Error;
 
 /// Retries a task instantly for `retries`
@@ -31,14 +29,15 @@ impl RetryPolicy {
     }
 }
 
-impl<T, Res> Policy<Req<T>, Res, Err> for RetryPolicy
+impl<T, Res, Ctx> Policy<Req<T, Ctx>, Res, Err> for RetryPolicy
 where
     T: Clone,
+    Ctx: Clone,
 {
     type Future = future::Ready<Self>;
 
-    fn retry(&self, req: &Req<T>, result: Result<&Res, &Err>) -> Option<Self::Future> {
-        let ctx = req.get::<Attempt>().cloned().unwrap_or_default();
+    fn retry(&self, req: &Req<T, Ctx>, result: Result<&Res, &Err>) -> Option<Self::Future> {
+        let attempt = &req.parts.attempt;
         match result {
             Ok(_) => {
                 // Treat all `Response`s as success,
@@ -46,22 +45,14 @@ where
                 None
             }
             Err(_) if self.retries == 0 => None,
-            Err(_) if (self.retries - ctx.current() > 0) => Some(future::ready(self.clone())),
+            Err(_) if (self.retries - attempt.current() > 0) => Some(future::ready(self.clone())),
             Err(_) => None,
         }
     }
 
-    fn clone_request(&self, req: &Req<T>) -> Option<Req<T>> {
-        let mut req = req.clone();
-        let value = req
-            .get::<Attempt>()
-            .cloned()
-            .map(|attempt| {
-                attempt.increment();
-                attempt
-            })
-            .unwrap_or_default();
-        req.insert(value);
+    fn clone_request(&self, req: &Req<T, Ctx>) -> Option<Req<T, Ctx>> {
+        let req = req.clone();
+        req.parts.attempt.increment();
         Some(req)
     }
 }
diff --git a/src/layers/sentry/mod.rs b/src/layers/sentry/mod.rs
index de6f9ae..7e6d50c 100644
--- a/src/layers/sentry/mod.rs
+++ b/src/layers/sentry/mod.rs
@@ -1,16 +1,13 @@
+use sentry_core::protocol;
 use std::fmt::Debug;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-
-use apalis_core::task::namespace::Namespace;
-use sentry_core::protocol;
 use tower::Layer;
 use tower::Service;
 
 use apalis_core::error::Error;
 use apalis_core::request::Request;
-use apalis_core::task::attempt::Attempt;
 use apalis_core::task::task_id::TaskId;
 
 /// Tower Layer that logs Job Details.
@@ -126,34 +123,39 @@ where
     }
 }
 
-impl<S, J, F, Res> Service<Request<J>> for SentryJobService<S>
+impl<Svc, Req, Ctx, Fut, Res> Service<Request<Req, Ctx>> for SentryJobService<Svc>
 where
-    S: Service<Request<J>, Response = Res, Error = Error, Future = F>,
-    F: Future<Output = Result<Res, Error>> + 'static,
+    Svc: Service<Request<Req, Ctx>, Response = Res, Error = Error, Future = Fut>,
+    Fut: Future<Output = Result<Res, Error>> + 'static,
 {
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = SentryHttpFuture<S::Future>;
+    type Response = Svc::Response;
+    type Error = Svc::Error;
+    type Future = SentryHttpFuture<Svc::Future>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, request: Request<J>) -> Self::Future {
-        let job_type = std::any::type_name::<J>().to_string();
-        let ctx = request.get::<Attempt>().cloned().unwrap_or_default();
-        let task_id = request.get::<TaskId>().unwrap();
-        let namespace = request.get::<Namespace>().unwrap();
-        let trx_ctx = sentry_core::TransactionContext::new(namespace, "apalis.job");
-
-        let job_details = Task {
+    fn call(&mut self, request: Request<Req, Ctx>) -> Self::Future {
+        let task_type = std::any::type_name::<Req>().to_string();
+        let attempt = &request.parts.attempt;
+        let task_id = &request.parts.task_id;
+        let namespace = request
+            .parts
+            .namespace
+            .as_ref()
+            .map(|s| s.0.as_str())
+            .unwrap_or(std::any::type_name::<Req>());
+        let trx_ctx = sentry_core::TransactionContext::new(namespace, "apalis.task");
+
+        let task_details = Task {
             id: task_id.clone(),
-            current_attempt: ctx.current().try_into().unwrap(),
-            namespace: job_type,
+            current_attempt: attempt.current().try_into().unwrap(),
+            namespace: task_type,
         };
 
         SentryHttpFuture {
-            on_first_poll: Some((job_details, trx_ctx)),
+            on_first_poll: Some((task_details, trx_ctx)),
             transaction: None,
             future: self.service.call(request),
         }
diff --git a/src/layers/tracing/make_span.rs b/src/layers/tracing/make_span.rs
index 4de8f65..2ef9eb3 100644
--- a/src/layers/tracing/make_span.rs
+++ b/src/layers/tracing/make_span.rs
@@ -8,22 +8,22 @@ use super::DEFAULT_MESSAGE_LEVEL;
 ///
 /// [`Span`]: tracing::Span
 /// [`Trace`]: super::Trace
-pub trait MakeSpan<B> {
+pub trait MakeSpan<B, Ctx> {
     /// Make a span from a request.
-    fn make_span(&mut self, request: &Request<B>) -> Span;
+    fn make_span(&mut self, request: &Request<B, Ctx>) -> Span;
 }
 
-impl<B> MakeSpan<B> for Span {
-    fn make_span(&mut self, _request: &Request<B>) -> Span {
+impl<B, Ctx> MakeSpan<B, Ctx> for Span {
+    fn make_span(&mut self, _request: &Request<B, Ctx>) -> Span {
         self.clone()
     }
 }
 
-impl<F, B> MakeSpan<B> for F
+impl<F, B, Ctx> MakeSpan<B, Ctx> for F
 where
-    F: FnMut(&Request<B>) -> Span,
+    F: FnMut(&Request<B, Ctx>) -> Span,
 {
-    fn make_span(&mut self, request: &Request<B>) -> Span {
+    fn make_span(&mut self, request: &Request<B, Ctx>) -> Span {
         self(request)
     }
 }
@@ -62,8 +62,8 @@ impl Default for DefaultMakeSpan {
     }
 }
 
-impl<B> MakeSpan<B> for DefaultMakeSpan {
-    fn make_span(&mut self, _req: &Request<B>) -> Span {
+impl<B, Ctx> MakeSpan<B, Ctx> for DefaultMakeSpan {
+    fn make_span(&mut self, _req: &Request<B, Ctx>) -> Span {
         // This ugly macro is needed, unfortunately, because `tracing::span!`
         // required the level argument to be static. Meaning we can't just pass
         // `self.level`.
diff --git a/src/layers/tracing/mod.rs b/src/layers/tracing/mod.rs
index 2ceb3e9..0f67509 100644
--- a/src/layers/tracing/mod.rs
+++ b/src/layers/tracing/mod.rs
@@ -3,7 +3,7 @@ mod on_failure;
 mod on_request;
 mod on_response;
 
-use apalis_core::{error::Error, request::Request};
+use apalis_core::request::Request;
 use std::{
     fmt::{self, Debug},
     pin::Pin,
@@ -289,26 +289,26 @@ impl<S, MakeSpan, OnRequest, OnResponse, OnFailure>
     }
 }
 
-impl<J, S, OnRequestT, OnResponseT, OnFailureT, MakeSpanT, F, Res> Service<Request<J>>
+impl<Req, S, OnRequestT, OnResponseT, OnFailureT, MakeSpanT, F, Res, Ctx> Service<Request<Req, Ctx>>
     for Trace<S, MakeSpanT, OnRequestT, OnResponseT, OnFailureT>
 where
-    S: Service<Request<J>, Response = Res, Error = Error, Future = F> + Unpin + Send + 'static,
+    S: Service<Request<Req, Ctx>, Response = Res, Future = F> + Unpin + Send + 'static,
     S::Error: fmt::Display + 'static,
-    MakeSpanT: MakeSpan<J>,
-    OnRequestT: OnRequest<J>,
+    MakeSpanT: MakeSpan<Req, Ctx>,
+    OnRequestT: OnRequest<Req, Ctx>,
     OnResponseT: OnResponse<Res> + Clone + 'static,
-    F: Future<Output = Result<Res, Error>> + 'static,
-    OnFailureT: OnFailure + Clone + 'static,
+    F: Future<Output = Result<Res, S::Error>> + 'static,
+    OnFailureT: OnFailure<S::Error> + Clone + 'static,
 {
     type Response = Res;
-    type Error = Error;
+    type Error = S::Error;
     type Future = ResponseFuture<F, OnResponseT, OnFailureT>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.inner.poll_ready(cx)
     }
 
-    fn call(&mut self, req: Request<J>) -> Self::Future {
+    fn call(&mut self, req: Request<Req, Ctx>) -> Self::Future {
         let span = self.make_span.make_span(&req);
         let start = Instant::now();
         let job = {
@@ -339,14 +339,14 @@ pin_project! {
     }
 }
 
-impl<Fut, OnResponseT, OnFailureT, Res> Future for ResponseFuture<Fut, OnResponseT, OnFailureT>
+impl<Fut, OnResponseT, OnFailureT, Res, E> Future for ResponseFuture<Fut, OnResponseT, OnFailureT>
 where
-    Fut: Future<Output = Result<Res, Error>>,
+    Fut: Future<Output = Result<Res, E>>,
 
     OnResponseT: OnResponse<Res>,
-    OnFailureT: OnFailure,
+    OnFailureT: OnFailure<E>,
 {
-    type Output = Result<Res, Error>;
+    type Output = Result<Res, E>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
diff --git a/src/layers/tracing/on_failure.rs b/src/layers/tracing/on_failure.rs
index 20bc071..43a5392 100644
--- a/src/layers/tracing/on_failure.rs
+++ b/src/layers/tracing/on_failure.rs
@@ -1,8 +1,6 @@
-use apalis_core::error::Error;
-
 use super::{LatencyUnit, DEFAULT_ERROR_LEVEL};
 
-use std::time::Duration;
+use std::{fmt::Display, time::Duration};
 use tracing::{Level, Span};
 
 /// Trait used to tell [`Trace`] what to do when a request fails.
@@ -11,7 +9,7 @@ use tracing::{Level, Span};
 /// `on_failure` callback is called.
 ///
 /// [`Trace`]: super::Trace
-pub trait OnFailure {
+pub trait OnFailure<E> {
     /// Do the thing.
     ///
     /// `latency` is the duration since the request was received.
@@ -23,19 +21,19 @@ pub trait OnFailure {
     /// [`Span`]: https://docs.rs/tracing/latest/tracing/span/index.html
     /// [record]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html#method.record
     /// [`TraceLayer::make_span_with`]: crate::layers::tracing::TraceLayer::make_span_with
-    fn on_failure(&mut self, error: &Error, latency: Duration, span: &Span);
+    fn on_failure(&mut self, error: &E, latency: Duration, span: &Span);
 }
 
-impl OnFailure for () {
+impl<E> OnFailure<E> for () {
     #[inline]
-    fn on_failure(&mut self, _: &Error, _: Duration, _: &Span) {}
+    fn on_failure(&mut self, _: &E, _: Duration, _: &Span) {}
 }
 
-impl<F> OnFailure for F
+impl<F, E> OnFailure<E> for F
 where
-    F: FnMut(&Error, Duration, &Span),
+    F: FnMut(&E, Duration, &Span),
 {
-    fn on_failure(&mut self, error: &Error, latency: Duration, span: &Span) {
+    fn on_failure(&mut self, error: &E, latency: Duration, span: &Span) {
         self(error, latency, span)
     }
 }
@@ -135,8 +133,8 @@ macro_rules! log_pattern_match {
     };
 }
 
-impl OnFailure for DefaultOnFailure {
-    fn on_failure(&mut self, error: &Error, latency: Duration, span: &Span) {
+impl<E: Display> OnFailure<E> for DefaultOnFailure {
+    fn on_failure(&mut self, error: &E, latency: Duration, span: &Span) {
         log_pattern_match!(
             self,
             span,
diff --git a/src/layers/tracing/on_request.rs b/src/layers/tracing/on_request.rs
index f0be6b3..c983d72 100644
--- a/src/layers/tracing/on_request.rs
+++ b/src/layers/tracing/on_request.rs
@@ -10,7 +10,7 @@ use tracing::Span;
 /// `on_request` callback is called.
 ///
 /// [`Trace`]: super::Trace
-pub trait OnRequest<B> {
+pub trait OnRequest<B, Ctx> {
     /// Do the thing.
     ///
     /// `span` is the `tracing` [`Span`], corresponding to this request, produced by the closure
@@ -20,19 +20,19 @@ pub trait OnRequest<B> {
     /// [`Span`]: https://docs.rs/tracing/latest/tracing/span/index.html
     /// [record]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html#method.record
     /// [`TraceLayer::make_span_with`]: crate::layers::tracing::TraceLayer::make_span_with
-    fn on_request(&mut self, request: &Request<B>, span: &Span);
+    fn on_request(&mut self, request: &Request<B, Ctx>, span: &Span);
 }
 
-impl<B> OnRequest<B> for () {
+impl<B, Ctx> OnRequest<B, Ctx> for () {
     #[inline]
-    fn on_request(&mut self, _: &Request<B>, _: &Span) {}
+    fn on_request(&mut self, _: &Request<B, Ctx>, _: &Span) {}
 }
 
-impl<B, F> OnRequest<B> for F
+impl<B, F, Ctx> OnRequest<B, Ctx> for F
 where
-    F: FnMut(&Request<B>, &Span),
+    F: FnMut(&Request<B, Ctx>, &Span),
 {
-    fn on_request(&mut self, request: &Request<B>, span: &Span) {
+    fn on_request(&mut self, request: &Request<B, Ctx>, span: &Span) {
         self(request, span)
     }
 }
@@ -76,8 +76,8 @@ impl DefaultOnRequest {
     }
 }
 
-impl<B> OnRequest<B> for DefaultOnRequest {
-    fn on_request(&mut self, _: &Request<B>, _: &Span) {
+impl<B, Ctx> OnRequest<B, Ctx> for DefaultOnRequest {
+    fn on_request(&mut self, _: &Request<B, Ctx>, _: &Span) {
         match self.level {
             Level::ERROR => {
                 tracing::event!(Level::ERROR, "job.start",);
diff --git a/src/lib.rs b/src/lib.rs
index 54892a4..493cd3e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -110,8 +110,8 @@ pub mod prelude {
         poller::{controller::Controller, FetchNext, Poller},
         request::{Request, RequestStream},
         response::IntoResponse,
-        service_fn::{service_fn, FromData, ServiceFn},
-        storage::{Storage, StorageStream},
+        service_fn::{service_fn, FromRequest, ServiceFn},
+        storage::Storage,
         task::attempt::Attempt,
         task::task_id::TaskId,
         worker::{Context, Event, Ready, Worker, WorkerError, WorkerId},