diff --git a/Cargo.lock b/Cargo.lock
index 240fc9ed7..e23b96b0b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2290,6 +2290,7 @@ dependencies = [
  "reqwest",
  "resolver_api",
  "serde_json",
+ "serror",
 ]
 
 [[package]]
@@ -2853,9 +2854,9 @@ dependencies = [
 
 [[package]]
 name = "serror"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ace3cd0543abaa9a05a1c4b5219c832aebf2a011ae31da4cf2b0d9808d6aea"
+checksum = "6bc462876e265831d80297a3898a173e3d5c72a1501dec9234423de2d25ac89c"
 dependencies = [
  "anyhow",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 1c3ee0186..d9844cd64 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ make_option = "0.1.7"
 resolver_api = "0.1.6"
 parse_csl = "0.1.0"
 mungos = "0.4.19"
-serror = "0.1.1"
+serror = "0.1.3"
 svi = "0.1.4"
 # external
 tokio = { version = "1.32.0", features = ["full"] }
diff --git a/bin/core/src/auth/mod.rs b/bin/core/src/auth/mod.rs
index fab88abfb..aa3ead9a0 100644
--- a/bin/core/src/auth/mod.rs
+++ b/bin/core/src/auth/mod.rs
@@ -7,7 +7,6 @@ use axum::{
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use reqwest::StatusCode;
 use resolver_api::Resolver;
-use serror::serialize_error;
 use uuid::Uuid;
 
 mod github;
@@ -17,8 +16,10 @@ mod local;
 mod secret;
 
 use crate::{
+    helpers::into_response_error,
     requests::auth::AuthRequest,
     state::{State, StateExtension},
+    ResponseResult,
 };
 
 pub use self::jwt::{InnerRequestUser, JwtClient, RequestUser, RequestUserExtension};
@@ -53,12 +54,11 @@ pub fn router(state: &State) -> Router {
                 if let Err(e) = &res {
                     info!("/auth request {req_id} | ERROR: {e:?}");
                 }
-                let res =
-                    res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                let res = res.map_err(into_response_error)?;
                 let elapsed = timer.elapsed();
                 info!("/auth request {req_id} | resolve time: {elapsed:?}");
                 debug!("/auth request {req_id} | RESPONSE: {res}");
-                Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
+                ResponseResult::Ok((TypedHeader(ContentType::json()), res))
             },
         ),
     );
diff --git a/bin/core/src/helpers/mod.rs b/bin/core/src/helpers/mod.rs
index 09ee3fbe0..d325241be 100644
--- a/bin/core/src/helpers/mod.rs
+++ b/bin/core/src/helpers/mod.rs
@@ -1,6 +1,7 @@
 use std::time::Duration;
 
 use anyhow::{anyhow, Context};
+use axum::{headers::ContentType, http::StatusCode, TypedHeader};
 use monitor_types::{
     entities::{
         deployment::{Deployment, DockerContainerState},
@@ -15,6 +16,7 @@ use monitor_types::{
 use mungos::mongodb::bson::{doc, to_bson};
 use periphery_client::{requests, PeripheryClient};
 use rand::{thread_rng, Rng};
+use serror::serialize_error_pretty;
 
 use crate::{auth::RequestUser, state::State};
 
@@ -57,6 +59,14 @@ pub fn make_update(
     }
 }
 
+pub fn into_response_error(e: anyhow::Error) -> (StatusCode, TypedHeader<ContentType>, String) {
+    (
+        StatusCode::INTERNAL_SERVER_ERROR,
+        TypedHeader(ContentType::json()),
+        serialize_error_pretty(e),
+    )
+}
+
 impl State {
     pub async fn get_user(&self, user_id: &str) -> anyhow::Result<User> {
         self.db
@@ -218,11 +228,11 @@ impl State {
 
     pub fn periphery_client(&self, server: &Server) -> anyhow::Result<PeripheryClient> {
         if !server.config.enabled {
-            return Err(anyhow!("server not enabled"))
+            return Err(anyhow!("server not enabled"));
         }
 
         let client = PeripheryClient::new(&server.config.address, &self.config.passkey);
-        
+
         Ok(client)
     }
 }
diff --git a/bin/core/src/main.rs b/bin/core/src/main.rs
index 2dbc75e97..aec03e1ae 100644
--- a/bin/core/src/main.rs
+++ b/bin/core/src/main.rs
@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate log;
 
-use axum::{Extension, Router};
+use axum::{Extension, Router, http::StatusCode, TypedHeader, headers::ContentType};
 use termination_signal::tokio::immediate_term_handle;
 use tower_http::cors::{Any, CorsLayer};
 
@@ -15,6 +15,8 @@ mod requests;
 mod state;
 mod ws;
 
+type ResponseResult<T> = Result<T, (StatusCode, TypedHeader<ContentType>, String)>;
+
 async fn app() -> anyhow::Result<()> {
     let state = state::State::load().await?;
 
diff --git a/bin/core/src/requests/execute/mod.rs b/bin/core/src/requests/execute/mod.rs
index f38488392..2f60ce6a7 100644
--- a/bin/core/src/requests/execute/mod.rs
+++ b/bin/core/src/requests/execute/mod.rs
@@ -1,20 +1,18 @@
 use std::time::Instant;
 
 use anyhow::Context;
-use axum::{
-    headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
-    TypedHeader,
-};
+use axum::{headers::ContentType, middleware, routing::post, Extension, Json, Router, TypedHeader};
 use monitor_types::requests::execute::*;
 use resolver_api::{derive::Resolver, Resolve, Resolver};
 use serde::{Deserialize, Serialize};
-use serror::serialize_error;
 use typeshare::typeshare;
 use uuid::Uuid;
 
 use crate::{
     auth::{auth_request, RequestUser, RequestUserExtension},
+    helpers::into_response_error,
     state::{State, StateExtension},
+    ResponseResult,
 };
 
 mod build;
@@ -68,16 +66,14 @@ pub fn router() -> Router {
                     if let Err(e) = &res {
                         info!("/execute request {req_id} SPAWN ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     if let Err(e) = &res {
                         info!("/execute request {req_id} ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     let elapsed = timer.elapsed();
                     info!("/execute request {req_id} | resolve time: {elapsed:?}");
-                    Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
+                    ResponseResult::Ok((TypedHeader(ContentType::json()), res))
                 },
             ),
         )
diff --git a/bin/core/src/requests/read/mod.rs b/bin/core/src/requests/read/mod.rs
index 1219fb00f..de51d29a2 100644
--- a/bin/core/src/requests/read/mod.rs
+++ b/bin/core/src/requests/read/mod.rs
@@ -2,19 +2,20 @@ use std::time::Instant;
 
 use async_trait::async_trait;
 use axum::{
-    headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
+    headers::ContentType, middleware, routing::post, Extension, Json, Router,
     TypedHeader,
 };
 use monitor_types::requests::read::*;
 use resolver_api::{derive::Resolver, Resolve, ResolveToString, Resolver};
 use serde::{Deserialize, Serialize};
-use serror::serialize_error;
 use typeshare::typeshare;
 use uuid::Uuid;
 
 use crate::{
     auth::{auth_request, RequestUser, RequestUserExtension},
+    helpers::into_response_error,
     state::{State, StateExtension},
+    ResponseResult,
 };
 
 mod alert;
@@ -135,16 +136,14 @@ pub fn router() -> Router {
                         "/read request {req_id} | user: {} ({}) | {request:?}",
                         user.username, user.id
                     );
-                    let res = state
-                        .resolve_request(request, user)
-                        .await;
+                    let res = state.resolve_request(request, user).await;
                     if let Err(e) = &res {
                         warn!("/read request {req_id} ERROR: {e:#?}");
                     }
-                    let res = res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     let elapsed = timer.elapsed();
                     debug!("/read request {req_id} | resolve time: {elapsed:?}");
-                    Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
+                    ResponseResult::Ok((TypedHeader(ContentType::json()), res))
                 },
             ),
         )
diff --git a/bin/core/src/requests/write/mod.rs b/bin/core/src/requests/write/mod.rs
index 2d5082689..253e40933 100644
--- a/bin/core/src/requests/write/mod.rs
+++ b/bin/core/src/requests/write/mod.rs
@@ -1,20 +1,18 @@
 use std::time::Instant;
 
 use anyhow::Context;
-use axum::{
-    headers::ContentType, http::StatusCode, middleware, routing::post, Extension, Json, Router,
-    TypedHeader,
-};
+use axum::{headers::ContentType, middleware, routing::post, Extension, Json, Router, TypedHeader};
 use monitor_types::requests::write::*;
 use resolver_api::{derive::Resolver, Resolve, Resolver};
 use serde::{Deserialize, Serialize};
-use serror::serialize_error;
 use typeshare::typeshare;
 use uuid::Uuid;
 
 use crate::{
     auth::{auth_request, RequestUser, RequestUserExtension},
+    helpers::into_response_error,
     state::{State, StateExtension},
+    ResponseResult,
 };
 
 mod alerter;
@@ -118,16 +116,14 @@ pub fn router() -> Router {
                     if let Err(e) = &res {
                         info!("/write request {req_id} SPAWN ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     if let Err(e) = &res {
                         info!("/write request {req_id} ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     let elapsed = timer.elapsed();
                     info!("/write request {req_id} | resolve time: {elapsed:?}");
-                    Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
+                    ResponseResult::Ok((TypedHeader(ContentType::json()), res))
                 },
             ),
         )
diff --git a/bin/migrator/src/main.rs b/bin/migrator/src/main.rs
index b8301591a..ff54c3188 100644
--- a/bin/migrator/src/main.rs
+++ b/bin/migrator/src/main.rs
@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use crate::config::State;
 
 #[macro_use]
diff --git a/bin/periphery/src/helpers/mod.rs b/bin/periphery/src/helpers/mod.rs
index 9054a54b6..001f7e9a7 100644
--- a/bin/periphery/src/helpers/mod.rs
+++ b/bin/periphery/src/helpers/mod.rs
@@ -1,7 +1,9 @@
 use anyhow::anyhow;
 use async_timing_util::unix_timestamp_ms;
+use axum::{http::StatusCode, TypedHeader, headers::ContentType};
 use monitor_types::entities::update::Log;
 use run_command::{async_run_command, CommandOutput};
+use serror::serialize_error_pretty;
 
 use crate::state::State;
 
@@ -59,3 +61,11 @@ pub fn output_into_log(stage: &str, command: String, start_ts: i64, output: Comm
         end_ts: unix_timestamp_ms() as i64,
     }
 }
+
+pub fn into_response_error(e: anyhow::Error) -> (StatusCode, TypedHeader<ContentType>, String) {
+    (
+        StatusCode::INTERNAL_SERVER_ERROR,
+        TypedHeader(ContentType::json()),
+        serialize_error_pretty(e),
+    )
+}
diff --git a/bin/periphery/src/main.rs b/bin/periphery/src/main.rs
index 498d0fb56..a39ffefd9 100644
--- a/bin/periphery/src/main.rs
+++ b/bin/periphery/src/main.rs
@@ -10,7 +10,6 @@ use axum::{
 };
 
 use resolver_api::Resolver;
-use serror::serialize_error;
 use termination_signal::tokio::immediate_term_handle;
 use uuid::Uuid;
 
@@ -23,6 +22,10 @@ mod state;
 use requests::PeripheryRequest;
 use state::State;
 
+use crate::helpers::into_response_error;
+
+type ResponseResult<T> = Result<T, (StatusCode, TypedHeader<ContentType>, String)>;
+
 async fn app() -> anyhow::Result<()> {
     let state = State::load().await?;
 
@@ -44,17 +47,15 @@ async fn app() -> anyhow::Result<()> {
                     if let Err(e) = &res {
                         debug!("request {req_id} SPAWN ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     if let Err(e) = &res {
                         debug!("request {req_id} ERROR: {e:#?}");
                     }
-                    let res =
-                        res.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, serialize_error(e)))?;
+                    let res = res.map_err(into_response_error)?;
                     let elapsed = timer.elapsed();
                     info!("request {req_id} | resolve time: {elapsed:?}");
                     debug!("request {req_id} RESPONSE: {res}");
-                    Result::<_, (StatusCode, String)>::Ok((TypedHeader(ContentType::json()), res))
+                    ResponseResult::Ok((TypedHeader(ContentType::json()), res))
                 },
             ),
         )
diff --git a/lib/periphery_client/Cargo.toml b/lib/periphery_client/Cargo.toml
index 0d7c79c75..73f591d63 100644
--- a/lib/periphery_client/Cargo.toml
+++ b/lib/periphery_client/Cargo.toml
@@ -14,4 +14,5 @@ reqwest.workspace = true
 anyhow.workspace = true
 serde_json.workspace = true
 log.workspace = true
-resolver_api.workspace = true
\ No newline at end of file
+resolver_api.workspace = true
+serror.workspace = true
\ No newline at end of file
diff --git a/lib/periphery_client/src/lib.rs b/lib/periphery_client/src/lib.rs
index 751ab6541..dbee55bb6 100644
--- a/lib/periphery_client/src/lib.rs
+++ b/lib/periphery_client/src/lib.rs
@@ -3,12 +3,13 @@ extern crate log;
 
 use std::time::Duration;
 
-use anyhow::{anyhow, Context};
+use anyhow::Context;
 use reqwest::StatusCode;
 use resolver_api::HasResponse;
 use serde_json::json;
 
 pub use monitor_periphery::requests;
+use serror::deserialize_error;
 
 pub struct PeripheryClient {
     reqwest: reqwest::Client,
@@ -54,7 +55,7 @@ impl PeripheryClient {
         if let Some(timeout) = timeout {
             req = req.timeout(timeout);
         }
-        let res = req.send().await?;
+        let res = req.send().await.context("failed at request to periphery")?;
         let status = res.status();
         debug!("got response | type: {req_type} | {status} | body: {res:?}",);
         if status == StatusCode::OK {
@@ -66,7 +67,11 @@ impl PeripheryClient {
                 .text()
                 .await
                 .context("failed to convert response to text")?;
-            Err(anyhow!("request failed | {status} | {text}"))
+
+            let error =
+                deserialize_error(text).context(format!("request to periphery failed | {status}"));
+
+            Err(error)
         }
     }
 }