diff --git a/Cargo.toml b/Cargo.toml
index 240b9e44..c9969e9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,6 +7,10 @@ edition = "2021"
 name = "pod2"
 path = "src/lib.rs"
 
+[[bin]]
+name = "pod2-server"
+path = "src/bin/server.rs"
+
 [dependencies]
 hex = "0.4.3"
 itertools = "0.14.0"
@@ -16,6 +20,18 @@ anyhow = "1.0.56"
 dyn-clone = "1.0.18"
 # enabled by features:
 plonky2 = { git = "https://github.com/0xPolygonZero/plonky2", optional = true }
+serde = "1.0.219"
+serde_json = "1.0.140"
+base64 = "0.22.1"
+# Web server dependencies
+actix-web = "4.4.1"
+actix-cors = "0.6.5"
+actix-files = "0.6.2"
+env_logger = "0.10.1"
+log = "0.4.20"
+uuid = { version = "1.5.0", features = ["v4", "serde"] }
+chrono = { version = "0.4.31", features = ["serde"] }
+futures = "0.3.28"
 
 [features]
 default = ["backend_plonky2"]
diff --git a/src/backends/plonky2/basetypes.rs b/src/backends/plonky2/basetypes.rs
index 12568756..ab68e01f 100644
--- a/src/backends/plonky2/basetypes.rs
+++ b/src/backends/plonky2/basetypes.rs
@@ -2,6 +2,10 @@
 //! `backend_plonky2` feature is enabled.
 //! See src/middleware/basetypes.rs for more details.
 
+use crate::frontend::serialization::{
+    deserialize_hash_tuple, deserialize_value_tuple, serialize_hash_tuple, serialize_value_tuple,
+};
+use crate::middleware::{Params, ToFields};
 use anyhow::{anyhow, Error, Result};
 use hex::{FromHex, FromHexError};
 use plonky2::field::goldilocks_field::GoldilocksField;
@@ -10,11 +14,10 @@ use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
 use plonky2::plonk::config::PoseidonGoldilocksConfig;
 use plonky2::plonk::proof::Proof as Plonky2Proof;
+use serde::{Deserialize, Serialize};
 use std::cmp::{Ord, Ordering};
 use std::fmt;
 
-use crate::middleware::{Params, ToFields};
-
 use crate::backends::counter;
 
 /// F is the native field we use everywhere.  Currently it's Goldilocks from plonky2
@@ -34,8 +37,14 @@ pub const EMPTY: Value = Value([F::ZERO, F::ZERO, F::ZERO, F::ZERO]);
 pub const SELF_ID_HASH: Hash = Hash([F::ONE, F::ZERO, F::ZERO, F::ZERO]);
 pub const NULL: Hash = Hash([F::ZERO, F::ZERO, F::ZERO, F::ZERO]);
 
-#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-pub struct Value(pub [F; VALUE_SIZE]);
+#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Value(
+    #[serde(
+        serialize_with = "serialize_value_tuple",
+        deserialize_with = "deserialize_value_tuple"
+    )]
+    pub [F; VALUE_SIZE],
+);
 
 impl ToFields for Value {
     fn to_fields(&self, _params: &Params) -> (Vec<F>, usize) {
@@ -117,8 +126,14 @@ impl fmt::Display for Value {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq)]
-pub struct Hash(pub [F; HASH_SIZE]);
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Hash(
+    #[serde(
+        serialize_with = "serialize_hash_tuple",
+        deserialize_with = "deserialize_hash_tuple"
+    )]
+    pub [F; HASH_SIZE],
+);
 
 pub fn hash_value(input: &Value) -> Hash {
     hash_fields(&input.0)
diff --git a/src/backends/plonky2/mock_main/mod.rs b/src/backends/plonky2/mock_main/mod.rs
index a4b4cad3..d8d842b4 100644
--- a/src/backends/plonky2/mock_main/mod.rs
+++ b/src/backends/plonky2/mock_main/mod.rs
@@ -1,7 +1,9 @@
 use anyhow::{anyhow, Result};
+use base64::prelude::*;
 use itertools::Itertools;
 use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
+use serde::{Deserialize, Serialize};
 use std::any::Any;
 use std::fmt;
 
@@ -26,14 +28,14 @@ impl PodProver for MockProver {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MockMainPod {
     params: Params,
     id: PodId,
-    input_signed_pods: Vec<Box<dyn Pod>>,
-    input_main_pods: Vec<Box<dyn Pod>>,
+    //   input_signed_pods: Vec<Box<dyn Pod>>,
+    //   input_main_pods: Vec<Box<dyn Pod>>,
     // New statements introduced by this pod
-    input_statements: Vec<Statement>,
+    //   input_statements: Vec<Statement>,
     public_statements: Vec<Statement>,
     operations: Vec<Operation>,
     // All statements (inherited + new)
@@ -331,9 +333,9 @@ impl MockMainPod {
         Ok(Self {
             params: params.clone(),
             id,
-            input_signed_pods,
-            input_main_pods,
-            input_statements,
+            //  input_signed_pods,
+            //  input_main_pods,
+            //  input_statements,
             public_statements,
             statements,
             operations,
@@ -468,6 +470,10 @@ impl Pod for MockMainPod {
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
+
+    fn serialized_proof(&self) -> String {
+        BASE64_STANDARD.encode(serde_json::to_string(self).unwrap())
+    }
 }
 
 #[cfg(test)]
diff --git a/src/backends/plonky2/mock_main/operation.rs b/src/backends/plonky2/mock_main/operation.rs
index 9e2bd962..460f7393 100644
--- a/src/backends/plonky2/mock_main/operation.rs
+++ b/src/backends/plonky2/mock_main/operation.rs
@@ -1,10 +1,10 @@
-use anyhow::Result;
-use std::fmt;
-
 use super::Statement;
 use crate::middleware::{self, OperationType};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::fmt;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum OperationArg {
     None,
     Index(usize),
@@ -16,7 +16,7 @@ impl OperationArg {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Operation(pub OperationType, pub Vec<OperationArg>);
 
 impl Operation {
diff --git a/src/backends/plonky2/mock_main/statement.rs b/src/backends/plonky2/mock_main/statement.rs
index 452a29c0..59c5be2c 100644
--- a/src/backends/plonky2/mock_main/statement.rs
+++ b/src/backends/plonky2/mock_main/statement.rs
@@ -1,11 +1,12 @@
 use anyhow::{anyhow, Result};
+use serde::{Deserialize, Serialize};
 use std::fmt;
 
 use crate::middleware::{
     self, AnchoredKey, NativePredicate, Params, Predicate, StatementArg, ToFields,
 };
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Statement(pub Predicate, pub Vec<StatementArg>);
 
 impl Statement {
diff --git a/src/backends/plonky2/mock_signed.rs b/src/backends/plonky2/mock_signed.rs
index d86264c2..b1e0ffc8 100644
--- a/src/backends/plonky2/mock_signed.rs
+++ b/src/backends/plonky2/mock_signed.rs
@@ -44,6 +44,16 @@ pub struct MockSignedPod {
     dict: Dictionary,
 }
 
+impl MockSignedPod {
+    pub fn new(id: PodId, signature: String, dict: Dictionary) -> Self {
+        Self {
+            id,
+            signature,
+            dict,
+        }
+    }
+}
+
 impl Pod for MockSignedPod {
     fn verify(&self) -> bool {
         // Verify type
@@ -100,6 +110,10 @@ impl Pod for MockSignedPod {
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
+
+    fn serialized_proof(&self) -> String {
+        self.signature.to_string()
+    }
 }
 
 #[cfg(test)]
diff --git a/src/bin/server.rs b/src/bin/server.rs
new file mode 100644
index 00000000..bda6de5f
--- /dev/null
+++ b/src/bin/server.rs
@@ -0,0 +1,49 @@
+use actix_cors::Cors;
+use actix_files::Files;
+use actix_web::{App, HttpServer, middleware::Logger};
+use actix_web::web;
+use log::info;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+use pod2::web::{
+    PodStorage,
+    get_pods, get_pod_by_id, create_signed_pod, import_pod, export_pod
+};
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+    
+    // Create pod storage
+    let storage: web::Data<PodStorage> = web::Data::new(Arc::new(RwLock::new(HashMap::new())));
+    
+    info!("Starting POD2 web server at http://127.0.0.1:8080");
+    
+    HttpServer::new(move || {
+        let cors = Cors::default()
+            .allow_any_origin()
+            .allow_any_method()
+            .allow_any_header()
+            .max_age(3600);
+        
+        App::new()
+            .wrap(Logger::default())
+            .wrap(cors)
+            .app_data(storage.clone())
+            // API routes
+            .service(
+                web::scope("/api")
+                    .route("/pods", web::get().to(get_pods))
+                    .route("/pods/{id}", web::get().to(get_pod_by_id))
+                    .route("/pods", web::post().to(create_signed_pod))
+                    .route("/pods/import", web::post().to(import_pod))
+                    .route("/pods/{id}/export", web::get().to(export_pod))
+            )
+            // Serve static files from 'static' directory
+            .service(Files::new("/", "static").index_file("index.html"))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
\ No newline at end of file
diff --git a/src/examples.rs b/src/examples.rs
index 59c971ab..c6db8adc 100644
--- a/src/examples.rs
+++ b/src/examples.rs
@@ -6,11 +6,11 @@ use std::collections::HashMap;
 
 use crate::backends::plonky2::mock_signed::MockSigner;
 use crate::frontend::{
+    containers::{Dictionary, Set},
     MainPodBuilder, Operation, OperationArg, SignedPod, SignedPodBuilder, Statement, Value,
 };
-use crate::middleware::containers::Set;
-use crate::middleware::{containers::Dictionary, Params, PodType, KEY_SIGNER, KEY_TYPE};
-use crate::middleware::{hash_str, CustomPredicateRef, NativeOperation, OperationType};
+use crate::middleware::{CustomPredicateRef, NativeOperation, OperationType};
+use crate::middleware::{Params, PodType, KEY_SIGNER, KEY_TYPE};
 use crate::op;
 
 // ZuKYC
@@ -28,10 +28,11 @@ pub fn zu_kyc_sign_pod_builders(
     pay_stub.insert("startDate", 1706367566);
 
     let mut sanction_list = SignedPodBuilder::new(params);
-    let sanctions_values = ["A343434340"].map(|s| crate::middleware::Value::from(hash_str(s)));
+    let sanctions_values = ["A343434340"].map(Value::from);
+
     sanction_list.insert(
         "sanctionList",
-        Value::Set(Set::new(&sanctions_values.to_vec()).unwrap()),
+        Value::Set(Set::new(sanctions_values.into())),
     );
 
     (gov_id, pay_stub, sanction_list)
@@ -337,7 +338,7 @@ pub fn great_boy_pod_full_flow() -> Result<MainPodBuilder> {
     alice_friend_pods.push(friend.sign(&mut bob_signer).unwrap());
     alice_friend_pods.push(friend.sign(&mut charlie_signer).unwrap());
 
-    let good_boy_issuers_dict = Value::Dictionary(Dictionary::new(&HashMap::new())?); // empty
+    let good_boy_issuers_dict = Value::Dictionary(Dictionary::new(HashMap::new())); // empty
     great_boy_pod_builder(
         &params,
         [
@@ -396,6 +397,6 @@ pub fn tickets_pod_full_flow() -> Result<MainPodBuilder> {
         &signed_pod,
         123,
         true,
-        &Value::Dictionary(Dictionary::new(&HashMap::new())?),
+        &Value::Dictionary(Dictionary::new(HashMap::new())),
     )
 }
diff --git a/src/frontend/containers.rs b/src/frontend/containers.rs
new file mode 100644
index 00000000..c89bf79a
--- /dev/null
+++ b/src/frontend/containers.rs
@@ -0,0 +1,107 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use super::Value;
+use crate::middleware::{
+    containers::{
+        Array as MiddlewareArray, Dictionary as MiddlewareDictionary, Set as MiddlewareSet,
+    },
+    hash_str, Value as MiddlewareValue,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct Set(Vec<Value>, #[serde(skip)] MiddlewareSet);
+
+impl Set {
+    pub fn new(values: Vec<Value>) -> Self {
+        let set =
+            MiddlewareSet::new(&values.iter().map(|v| MiddlewareValue::from(v)).collect()).unwrap();
+        Self(values, set)
+    }
+
+    pub fn middleware_set(&self) -> &MiddlewareSet {
+        &self.1
+    }
+
+    pub fn values(&self) -> &Vec<Value> {
+        &self.0
+    }
+}
+
+impl<'de> Deserialize<'de> for Set {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values: Vec<Value> = Vec::deserialize(deserializer)?;
+        Ok(Set::new(values))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct Dictionary(HashMap<String, Value>, #[serde(skip)] MiddlewareDictionary);
+
+impl Dictionary {
+    pub fn new(values: HashMap<String, Value>) -> Self {
+        let dict = MiddlewareDictionary::new(
+            &values
+                .iter()
+                .map(|(k, v)| (hash_str(k), MiddlewareValue::from(v)))
+                .collect::<HashMap<_, _>>(),
+        )
+        .unwrap();
+        Self(values, dict)
+    }
+
+    pub fn middleware_dict(&self) -> &MiddlewareDictionary {
+        &self.1
+    }
+
+    pub fn values(&self) -> &HashMap<String, Value> {
+        &self.0
+    }
+}
+
+impl<'de> Deserialize<'de> for Dictionary {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values: HashMap<String, Value> = HashMap::deserialize(deserializer)?;
+        Ok(Dictionary::new(values))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(transparent)]
+pub struct Array(Vec<Value>, #[serde(skip)] MiddlewareArray);
+
+impl Array {
+    pub fn new(values: Vec<Value>) -> Self {
+        let array =
+            MiddlewareArray::new(&values.iter().map(|v| MiddlewareValue::from(v)).collect())
+                .unwrap();
+        Self(values, array)
+    }
+
+    pub fn middleware_array(&self) -> &MiddlewareArray {
+        &self.1
+    }
+
+    pub fn values(&self) -> &Vec<Value> {
+        &self.0
+    }
+}
+
+impl<'de> Deserialize<'de> for Array {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values: Vec<Value> = Vec::deserialize(deserializer)?;
+        Ok(Array::new(values))
+    }
+}
diff --git a/src/frontend/mod.rs b/src/frontend/mod.rs
index 69a42363..067a1e51 100644
--- a/src/frontend/mod.rs
+++ b/src/frontend/mod.rs
@@ -1,29 +1,31 @@
 //! The frontend includes the user-level abstractions and user-friendly types to define and work
 //! with Pods.
 
+use crate::frontend::serialization::*;
+use crate::middleware::{
+    self, hash_str, Hash, MainPodInputs, NativeOperation, NativePredicate, Params, PodId,
+    PodProver, PodSigner, SELF,
+};
+use crate::middleware::{OperationType, Predicate, KEY_SIGNER, KEY_TYPE};
 use anyhow::{anyhow, Error, Result};
+use containers::{Array, Dictionary, Set};
 use itertools::Itertools;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::convert::From;
 use std::{fmt, hash as h};
 
-use crate::middleware::{
-    self,
-    containers::{Array, Dictionary, Set},
-    hash_str, Hash, MainPodInputs, NativeOperation, NativePredicate, Params, PodId, PodProver,
-    PodSigner, SELF,
-};
-use crate::middleware::{OperationType, Predicate, KEY_SIGNER, KEY_TYPE};
-
+pub mod containers;
 mod custom;
 mod operation;
+pub mod serialization;
 mod statement;
 pub use custom::*;
 pub use operation::*;
 pub use statement::*;
 
 /// This type is just for presentation purposes.
-#[derive(Clone, Debug, Default, h::Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, h::Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PodClass {
     #[default]
     Signed,
@@ -31,18 +33,34 @@ pub enum PodClass {
 }
 
 // An Origin, which represents a reference to an ancestor POD.
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Default, Serialize, Deserialize)]
 pub struct Origin(pub PodClass, pub PodId);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Value {
-    String(String),
-    Int(i64),
-    Bool(bool),
-    Dictionary(Dictionary),
+    // Serde cares about the order of the enum variants, with untagged variants
+    // appearing at the end.
+    // Variants without "untagged" will be serialized as "tagged" values by
+    // default, meaning that a Set appears in JSON as {"Set":[...]}
+    // and not as [...]
+    // Arrays, Strings and Booleans are untagged, as there is a natural JSON
+    // representation for them that is unambiguous to deserialize and is fully
+    // compatible with the semantics of the POD types.
+    // As JSON integers do not specify precision, and JavaScript is limited to
+    // 53-bit precision for integers, integers are represented as tagged
+    // strings, with a custom serializer and deserializer.
     Set(Set),
-    Array(Array),
+    Dictionary(Dictionary),
+    #[serde(serialize_with = "serialize_i64", deserialize_with = "deserialize_i64")]
+    Int(i64),
+    // Uses the serialization for middleware::Value:
     Raw(middleware::Value),
+    #[serde(untagged)]
+    Array(Array),
+    #[serde(untagged)]
+    String(String),
+    #[serde(untagged)]
+    Bool(bool),
 }
 
 impl From<&str> for Value {
@@ -69,9 +87,9 @@ impl From<&Value> for middleware::Value {
             Value::String(s) => hash_str(s).value(),
             Value::Int(v) => middleware::Value::from(*v),
             Value::Bool(b) => middleware::Value::from(*b as i64),
-            Value::Dictionary(d) => d.commitment().value(),
-            Value::Set(s) => s.commitment().value(),
-            Value::Array(a) => a.commitment().value(),
+            Value::Dictionary(d) => d.middleware_dict().commitment().value(),
+            Value::Set(s) => s.middleware_set().commitment().value(),
+            Value::Array(a) => a.middleware_array().commitment().value(),
             Value::Raw(v) => *v,
         }
     }
@@ -100,9 +118,9 @@ impl fmt::Display for Value {
             Value::String(s) => write!(f, "\"{}\"", s),
             Value::Int(v) => write!(f, "{}", v),
             Value::Bool(b) => write!(f, "{}", b),
-            Value::Dictionary(d) => write!(f, "dict:{}", d.commitment()),
-            Value::Set(s) => write!(f, "set:{}", s.commitment()),
-            Value::Array(a) => write!(f, "arr:{}", a.commitment()),
+            Value::Dictionary(d) => write!(f, "dict:{}", d.middleware_dict().commitment()),
+            Value::Set(s) => write!(f, "set:{}", s.middleware_set().commitment()),
+            Value::Array(a) => write!(f, "arr:{}", a.middleware_array().commitment()),
             Value::Raw(v) => write!(f, "{}", v),
         }
     }
@@ -220,7 +238,7 @@ impl SignedPod {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Serialize, Deserialize)]
 pub struct AnchoredKey(pub Origin, pub String);
 
 impl From<AnchoredKey> for middleware::AnchoredKey {
diff --git a/src/frontend/serialization.rs b/src/frontend/serialization.rs
new file mode 100644
index 00000000..208b745c
--- /dev/null
+++ b/src/frontend/serialization.rs
@@ -0,0 +1,299 @@
+use std::collections::HashMap;
+
+use base64::prelude::*;
+use serde::ser::{SerializeStruct, Serializer};
+use serde::{Deserialize, Serialize};
+
+use crate::backends::plonky2::mock_main::MockMainPod;
+use crate::backends::plonky2::mock_signed::MockSignedPod;
+use crate::frontend::containers::Dictionary;
+use crate::frontend::Statement;
+use crate::middleware::{PodId, F};
+use crate::middleware::{HASH_SIZE, VALUE_SIZE};
+use plonky2::field::types::Field;
+
+use super::Value;
+use super::{MainPod, SignedPod};
+
+impl Serialize for SignedPod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("SignedPod", 3)?;
+        state.serialize_field(
+            "entries",
+            &self
+                .kvs
+                .iter()
+                .map(|(k, v)| (k.clone(), v))
+                .collect::<HashMap<String, &Value>>(),
+        )?;
+
+        let signature = self.pod.serialized_proof();
+
+        state.serialize_field("proof", &signature)?;
+        state.serialize_field("pod_class", "Signed")?;
+        state.serialize_field("pod_type", "Mock")?;
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for SignedPod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct SignedPodHelper {
+            entries: HashMap<String, Value>,
+            proof: String,
+            pod_class: String,
+            pod_type: String,
+        }
+
+        let helper = SignedPodHelper::deserialize(deserializer)?;
+        if helper.pod_class != "Signed" {
+            return Err(serde::de::Error::custom("pod_class is not Signed"));
+        }
+        if helper.pod_type != "Mock" {
+            return Err(serde::de::Error::custom("pod_type is not Mock"));
+        }
+        let kvs = helper.entries;
+        let dict = Dictionary::new(kvs.clone()).middleware_dict().clone();
+        let pod = MockSignedPod::new(PodId(dict.commitment()), helper.proof, dict);
+        Ok(SignedPod {
+            pod: Box::new(pod),
+            kvs: kvs,
+        })
+    }
+}
+
+impl Serialize for MainPod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("MainPod", 2)?;
+        state.serialize_field("public_statements", &self.public_statements)?;
+        state.serialize_field("proof", &self.pod.serialized_proof())?;
+        state.serialize_field("pod_class", "Main")?;
+        state.serialize_field("pod_type", "Mock")?;
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for MainPod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct MainPodHelper {
+            public_statements: Vec<Statement>,
+            proof: String,
+            pod_class: String,
+            pod_type: String,
+        }
+
+        let helper = MainPodHelper::deserialize(deserializer)?;
+        if helper.pod_class != "Main" {
+            return Err(serde::de::Error::custom("pod_class is not Main"));
+        }
+        if helper.pod_type != "Mock" {
+            return Err(serde::de::Error::custom("pod_type is not Mock"));
+        }
+        let proof = String::from_utf8(BASE64_STANDARD.decode(&helper.proof).unwrap()).unwrap();
+        let pod: MockMainPod = serde_json::from_str(&proof).unwrap();
+
+        Ok(MainPod {
+            pod: Box::new(pod),
+            public_statements: helper.public_statements,
+        })
+    }
+}
+
+pub fn serialize_i64<S>(value: &i64, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&value.to_string())
+}
+
+pub fn deserialize_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    String::deserialize(deserializer)?
+        .parse()
+        .map_err(serde::de::Error::custom)
+}
+
+fn serialize_field_tuple<S, const N: usize>(
+    value: &[F; N],
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&format!(
+        "{:016x}{:016x}{:016x}{:016x}",
+        value[0].0, value[1].0, value[2].0, value[3].0
+    ))
+}
+
+fn deserialize_field_tuple<'de, D, const N: usize>(deserializer: D) -> Result<[F; N], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let hex_str = String::deserialize(deserializer)?;
+    let mut v = [F::ZERO; N];
+    for i in 0..N {
+        let start = i * 16;
+        let end = start + 16;
+        let hex_part = &hex_str[start..end];
+        v[i] = F::from_canonical_u64(
+            u64::from_str_radix(hex_part, 16).map_err(serde::de::Error::custom)?,
+        );
+    }
+    Ok(v)
+}
+
+pub fn serialize_hash_tuple<S>(value: &[F; HASH_SIZE], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serialize_field_tuple::<S, HASH_SIZE>(value, serializer)
+}
+
+pub fn deserialize_hash_tuple<'de, D>(deserializer: D) -> Result<[F; HASH_SIZE], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    deserialize_field_tuple::<D, HASH_SIZE>(deserializer)
+}
+
+pub fn serialize_value_tuple<S>(value: &[F; VALUE_SIZE], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serialize_field_tuple::<S, VALUE_SIZE>(value, serializer)
+}
+
+pub fn deserialize_value_tuple<'de, D>(deserializer: D) -> Result<[F; VALUE_SIZE], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    deserialize_field_tuple::<D, VALUE_SIZE>(deserializer)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        backends::plonky2::{mock_main::MockProver, mock_signed::MockSigner},
+        examples::{zu_kyc_pod_builder, zu_kyc_sign_pod_builders},
+        frontend::{
+            containers::{Array, Dictionary, Set},
+            SignedPodBuilder,
+        },
+        middleware::{self, Params},
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_value_serialization() {
+        let values = vec![
+            Value::String("hello".to_string()),
+            Value::Int(42),
+            Value::Bool(true),
+        ];
+
+        for value in values {
+            let serialized = serde_json::to_string(&value).unwrap();
+            let deserialized: Value = serde_json::from_str(&serialized).unwrap();
+            assert_eq!(value, deserialized);
+        }
+    }
+
+    #[test]
+    fn test_serialized_signed_pod() {
+        let mut entries = HashMap::new();
+        entries.insert("name".to_string(), Value::String("test".to_string()));
+        entries.insert("age".to_string(), Value::Int(30));
+
+        let mut signer = MockSigner { pk: "test".into() };
+        let mut builder = SignedPodBuilder::new(&Params::default());
+        builder.insert("name", "test");
+        builder.insert("age", 30);
+        builder.insert("very_large_int", 1152921504606846976);
+        builder.insert(
+            "a_dict_containing_one_key",
+            Value::Dictionary(Dictionary::new(HashMap::from([
+                ("foo".to_string(), Value::Int(123)),
+                (
+                    "an_array_containing_three_ints".to_string(),
+                    Value::Array(Array::new(vec![
+                        Value::Int(1),
+                        Value::Int(2),
+                        Value::Int(3),
+                    ])),
+                ),
+                (
+                    "a_set_containing_two_strings".to_string(),
+                    Value::Set(Set::new(vec![
+                        Value::Array(Array::new(vec![
+                            Value::String("foo".to_string()),
+                            Value::String("bar".to_string()),
+                        ])),
+                        Value::String("baz".to_string()),
+                    ])),
+                ),
+            ]))),
+        );
+
+        let pod = builder.sign(&mut signer).unwrap();
+
+        let serialized = serde_json::to_string(&pod).unwrap();
+        println!("serialized: {}", serialized);
+        let deserialized: SignedPod = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(pod.kvs, deserialized.kvs);
+        assert_eq!(pod.origin(), deserialized.origin());
+        assert_eq!(pod.verify(), deserialized.verify());
+        assert_eq!(pod.id(), deserialized.id())
+    }
+
+    #[test]
+    fn test_main_pod_serialization() {
+        let params = middleware::Params::default();
+
+        let (gov_id_builder, pay_stub_builder, sanction_list_builder) =
+            zu_kyc_sign_pod_builders(&params);
+        let mut signer = MockSigner {
+            pk: "ZooGov".into(),
+        };
+        let gov_id_pod = gov_id_builder.sign(&mut signer).unwrap();
+        let mut signer = MockSigner {
+            pk: "ZooDeel".into(),
+        };
+        let pay_stub_pod = pay_stub_builder.sign(&mut signer).unwrap();
+        let mut signer = MockSigner {
+            pk: "ZooOFAC".into(),
+        };
+        let sanction_list_pod = sanction_list_builder.sign(&mut signer).unwrap();
+        let kyc_builder =
+            zu_kyc_pod_builder(&params, &gov_id_pod, &pay_stub_pod, &sanction_list_pod).unwrap();
+
+        let mut prover = MockProver {};
+        let kyc_pod = kyc_builder.prove(&mut prover, &params).unwrap();
+
+        let serialized = serde_json::to_string(&kyc_pod).unwrap();
+        println!("serialized: {}", serialized);
+        let deserialized: MainPod = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(kyc_pod.public_statements, deserialized.public_statements);
+        assert_eq!(kyc_pod.pod.id(), deserialized.pod.id());
+        assert_eq!(kyc_pod.pod.verify(), deserialized.pod.verify());
+    }
+}
diff --git a/src/frontend/statement.rs b/src/frontend/statement.rs
index 5b4b3963..c96f608d 100644
--- a/src/frontend/statement.rs
+++ b/src/frontend/statement.rs
@@ -1,10 +1,10 @@
-use anyhow::{anyhow, Result};
-use std::fmt;
-
 use super::{AnchoredKey, SignedPod, Value};
 use crate::middleware::{self, NativePredicate, Predicate};
+use anyhow::{anyhow, Result};
+use serde::{Deserialize, Serialize};
+use std::fmt;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum StatementArg {
     Literal(Value),
     Key(AnchoredKey),
@@ -19,7 +19,7 @@ impl fmt::Display for StatementArg {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Statement(pub Predicate, pub Vec<StatementArg>);
 
 impl From<(&SignedPod, &str)> for Statement {
diff --git a/src/lib.rs b/src/lib.rs
index 325164ab..feb7cfdf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@ pub mod constants;
 pub mod frontend;
 pub mod middleware;
 mod util;
+pub mod web;
 
 #[cfg(test)]
 pub mod examples;
diff --git a/src/middleware/custom.rs b/src/middleware/custom.rs
index 1c133cdc..8d7034e7 100644
--- a/src/middleware/custom.rs
+++ b/src/middleware/custom.rs
@@ -5,17 +5,17 @@ use std::{fmt, hash as h, iter::zip};
 use anyhow::{anyhow, Result};
 use plonky2::field::types::Field;
 
-use crate::backends::plonky2::basetypes::HASH_SIZE;
-use crate::util::hashmap_insert_no_dupe;
-
 use super::{
     hash_fields, AnchoredKey, Hash, NativePredicate, Params, PodId, Statement, StatementArg,
     ToFields, Value, F,
 };
+use crate::backends::plonky2::basetypes::HASH_SIZE;
+use crate::util::hashmap_insert_no_dupe;
+use serde::{Deserialize, Serialize};
 
 // BEGIN Custom 1b
 
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Serialize, Deserialize)]
 pub enum HashOrWildcard {
     Hash(Hash),
     Wildcard(usize),
@@ -64,7 +64,7 @@ impl ToFields for HashOrWildcard {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Serialize, Deserialize)]
 pub enum StatementTmplArg {
     None,
     Literal(Value),
@@ -150,7 +150,7 @@ impl fmt::Display for StatementTmplArg {
 // END
 
 /// Statement Template for a Custom Predicate
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct StatementTmpl(pub Predicate, pub Vec<StatementTmplArg>);
 
 impl StatementTmpl {
@@ -205,7 +205,7 @@ impl ToFields for StatementTmpl {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CustomPredicate {
     /// NOTE: fields are not public (outside of crate) to enforce the struct instantiation through
     /// the `::and/or` methods, which performs checks on the values.
@@ -293,7 +293,7 @@ impl fmt::Display for CustomPredicate {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CustomPredicateBatch {
     pub name: String,
     pub predicates: Vec<CustomPredicate>,
@@ -331,7 +331,7 @@ impl CustomPredicateBatch {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CustomPredicateRef(pub Arc<CustomPredicateBatch>, pub usize);
 
 impl CustomPredicateRef {
@@ -390,7 +390,7 @@ impl CustomPredicateRef {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Predicate {
     Native(NativePredicate),
     BatchSelf(usize),
diff --git a/src/middleware/mod.rs b/src/middleware/mod.rs
index 5ae61078..1c69b7f5 100644
--- a/src/middleware/mod.rs
+++ b/src/middleware/mod.rs
@@ -13,6 +13,7 @@ pub use statement::*;
 
 use anyhow::Result;
 use dyn_clone::DynClone;
+use serde::{Deserialize, Serialize};
 use std::any::Any;
 use std::collections::HashMap;
 use std::fmt;
@@ -32,7 +33,7 @@ impl fmt::Display for PodId {
 }
 
 /// AnchoredKey is a tuple containing (OriginId: PodId, key: Hash)
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct AnchoredKey(pub PodId, pub Hash);
 
 impl AnchoredKey {
@@ -54,7 +55,7 @@ impl fmt::Display for AnchoredKey {
 /// An entry consists of a key-value pair.
 pub type Entry = (String, Value);
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
 pub struct PodId(pub Hash);
 
 impl ToFields for PodId {
@@ -77,7 +78,7 @@ impl From<PodType> for Value {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Params {
     pub max_input_signed_pods: usize,
     pub max_input_main_pods: usize,
@@ -150,7 +151,7 @@ impl Params {
     }
 }
 
-pub trait Pod: fmt::Debug + DynClone {
+pub trait Pod: fmt::Debug + DynClone + Send + Sync {
     fn verify(&self) -> bool;
     fn id(&self) -> PodId;
     fn pub_statements(&self) -> Vec<Statement>;
@@ -166,6 +167,7 @@ pub trait Pod: fmt::Debug + DynClone {
     }
     // Used for downcasting
     fn into_any(self: Box<Self>) -> Box<dyn Any>;
+    fn serialized_proof(&self) -> String;
 }
 
 // impl Clone for Box<dyn SignedPod>
@@ -193,6 +195,9 @@ impl Pod for NonePod {
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
+    fn serialized_proof(&self) -> String {
+        "".to_string()
+    }
 }
 
 #[derive(Debug)]
diff --git a/src/middleware/operation.rs b/src/middleware/operation.rs
index cdfcd020..c74a0af8 100644
--- a/src/middleware/operation.rs
+++ b/src/middleware/operation.rs
@@ -1,17 +1,17 @@
-use std::fmt;
-
 use anyhow::{anyhow, Result};
+use serde::{Deserialize, Serialize};
+use std::fmt;
 
 use super::{CustomPredicateRef, NativePredicate, Statement, StatementArg};
 use crate::middleware::{AnchoredKey, Params, Predicate, Value, SELF};
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum OperationType {
     Native(NativeOperation),
     Custom(CustomPredicateRef),
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum NativeOperation {
     None = 0,
     NewEntry = 1,
diff --git a/src/middleware/statement.rs b/src/middleware/statement.rs
index 6b03d511..1b3186bb 100644
--- a/src/middleware/statement.rs
+++ b/src/middleware/statement.rs
@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Result};
 use plonky2::field::types::Field;
+use serde::{Deserialize, Serialize};
 use std::fmt;
 use strum_macros::FromRepr;
 
@@ -9,7 +10,7 @@ pub const KEY_SIGNER: &str = "_signer";
 pub const KEY_TYPE: &str = "_type";
 pub const STATEMENT_ARG_F_LEN: usize = 8;
 
-#[derive(Clone, Copy, Debug, FromRepr, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, FromRepr, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum NativePredicate {
     None = 0,
     ValueOf = 1,
@@ -214,7 +215,7 @@ impl fmt::Display for Statement {
 }
 
 /// Statement argument type. Useful for statement decompositions.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum StatementArg {
     None,
     Literal(Value),
diff --git a/src/web/mod.rs b/src/web/mod.rs
new file mode 100644
index 00000000..386e81ec
--- /dev/null
+++ b/src/web/mod.rs
@@ -0,0 +1,240 @@
+// Web module for POD2 Web Viewer
+// Contains API handlers and storage utilities
+
+use actix_web::{web, HttpResponse, Responder};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use uuid::Uuid;
+
+use crate::frontend::{SignedPod, SignedPodBuilder, Value};
+use crate::middleware::{Params, PodSigner, KEY_SIGNER, KEY_TYPE};
+use crate::backends::plonky2::mock_signed::MockSigner;
+
+// Type alias for our in-memory storage
+pub type PodStorage = Arc<RwLock<HashMap<String, SignedPod>>>;
+
+// API Models
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PodListResponse {
+    pub pods: Vec<PodInfo>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PodInfo {
+    pub id: String,
+    pub pod_class: String,
+    pub signer: String,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PodDetailResponse {
+    pub id: String,
+    pub pod_class: String,
+    pub signer: String, 
+    pub entries: HashMap<String, Value>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub is_valid: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CreateSignedPodRequest {
+    pub entries: HashMap<String, serde_json::Value>,
+    pub signer: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ImportPodRequest {
+    pub pod_data: String, // JSON serialized pod
+}
+
+// Helper to convert JSON values to POD values
+fn json_to_pod_value(value: &serde_json::Value) -> Result<Value> {
+    match value {
+        serde_json::Value::String(s) => Ok(Value::String(s.clone())),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Ok(Value::Int(i))
+            } else {
+                anyhow::bail!("Number not representable as i64")
+            }
+        },
+        serde_json::Value::Bool(b) => Ok(Value::Bool(*b)),
+        serde_json::Value::Array(_) => {
+            anyhow::bail!("Array values not implemented yet")
+        },
+        serde_json::Value::Object(_) => {
+            anyhow::bail!("Object values not implemented yet")
+        },
+        serde_json::Value::Null => {
+            anyhow::bail!("Null values not supported")
+        },
+    }
+}
+
+// API Handlers
+pub async fn get_pods(storage: web::Data<PodStorage>) -> impl Responder {
+    let storage = storage.read().unwrap();
+    
+    let pods: Vec<PodInfo> = storage
+        .iter()
+        .map(|(id, pod)| {
+            // Get signer from pod
+            let signer = pod.kvs.get(KEY_SIGNER)
+                .map(|v| v.to_string())
+                .unwrap_or_else(|| "Unknown".to_string());
+            
+            PodInfo {
+                id: id.clone(),
+                pod_class: "Signed".to_string(), // Currently only handling SignedPods
+                signer,
+                created_at: chrono::Utc::now(), // We don't store creation time yet
+            }
+        })
+        .collect();
+    
+    HttpResponse::Ok().json(PodListResponse { pods })
+}
+
+pub async fn get_pod_by_id(
+    id: web::Path<String>,
+    storage: web::Data<PodStorage>
+) -> impl Responder {
+    let storage = storage.read().unwrap();
+    
+    match storage.get(id.as_str()) {
+        Some(pod) => {
+            // Get signer from pod
+            let signer = pod.kvs.get(KEY_SIGNER)
+                .map(|v| v.to_string())
+                .unwrap_or_else(|| "Unknown".to_string());
+            
+            let response = PodDetailResponse {
+                id: id.to_string(),
+                pod_class: "Signed".to_string(),
+                signer,
+                entries: pod.kvs.clone(),
+                created_at: chrono::Utc::now(), // We don't store creation time yet
+                is_valid: pod.verify(),
+            };
+            
+            HttpResponse::Ok().json(response)
+        },
+        None => HttpResponse::NotFound().json(serde_json::json!({
+            "error": "Pod not found"
+        }))
+    }
+}
+
+pub async fn create_signed_pod(
+    req: web::Json<CreateSignedPodRequest>,
+    storage: web::Data<PodStorage>
+) -> impl Responder {
+    // Convert entries to POD values
+    let mut pod_entries = HashMap::new();
+    for (key, value) in &req.entries {
+        match json_to_pod_value(value) {
+            Ok(pod_value) => {
+                pod_entries.insert(key.clone(), pod_value);
+            },
+            Err(e) => {
+                return HttpResponse::BadRequest().json(serde_json::json!({
+                    "error": format!("Failed to convert value for key '{}': {}", key, e)
+                }));
+            }
+        }
+    }
+    
+    // Create and sign the pod
+    let params = Params::default();
+    let mut builder = SignedPodBuilder::new(&params);
+    
+    // Add entries to the pod
+    for (key, value) in pod_entries {
+        builder.insert(key, value);
+    }
+    
+    // Create a mock signer with the requested key
+    let mut signer = MockSigner { pk: req.signer.clone() };
+    
+    // Sign the pod
+    match builder.sign(&mut signer) {
+        Ok(pod) => {
+            // Generate a UUID for the pod
+            let pod_id = Uuid::new_v4().to_string();
+            
+            // Store the pod
+            let mut storage = storage.write().unwrap();
+            storage.insert(pod_id.clone(), pod.clone());
+            
+            // Return the pod ID
+            HttpResponse::Created().json(serde_json::json!({
+                "id": pod_id,
+                "message": "Pod created successfully"
+            }))
+        },
+        Err(e) => {
+            HttpResponse::InternalServerError().json(serde_json::json!({
+                "error": format!("Failed to sign pod: {}", e)
+            }))
+        }
+    }
+}
+
+pub async fn import_pod(
+    req: web::Json<ImportPodRequest>,
+    storage: web::Data<PodStorage>
+) -> impl Responder {
+    // Deserialize the pod
+    match serde_json::from_str::<SignedPod>(&req.pod_data) {
+        Ok(pod) => {
+            // Generate a UUID for the pod
+            let pod_id = Uuid::new_v4().to_string();
+            
+            // Store the pod
+            let mut storage = storage.write().unwrap();
+            storage.insert(pod_id.clone(), pod);
+            
+            // Return the pod ID
+            HttpResponse::Created().json(serde_json::json!({
+                "id": pod_id,
+                "message": "Pod imported successfully"
+            }))
+        },
+        Err(e) => {
+            HttpResponse::BadRequest().json(serde_json::json!({
+                "error": format!("Failed to deserialize pod: {}", e)
+            }))
+        }
+    }
+}
+
+pub async fn export_pod(
+    id: web::Path<String>,
+    storage: web::Data<PodStorage>
+) -> impl Responder {
+    let storage = storage.read().unwrap();
+    
+    match storage.get(id.as_str()) {
+        Some(pod) => {
+            // Serialize the pod to JSON
+            match serde_json::to_string(&pod) {
+                Ok(pod_json) => {
+                    HttpResponse::Ok().json(serde_json::json!({
+                        "pod_data": pod_json
+                    }))
+                },
+                Err(e) => {
+                    HttpResponse::InternalServerError().json(serde_json::json!({
+                        "error": format!("Failed to serialize pod: {}", e)
+                    }))
+                }
+            }
+        },
+        None => HttpResponse::NotFound().json(serde_json::json!({
+            "error": "Pod not found"
+        }))
+    }
+}
\ No newline at end of file
diff --git a/static/css/style.css b/static/css/style.css
new file mode 100644
index 00000000..5619d2d2
--- /dev/null
+++ b/static/css/style.css
@@ -0,0 +1,396 @@
+:root {
+    --primary-color: #3498db;
+    --secondary-color: #2980b9;
+    --background-color: #ecf0f1;
+    --card-background: #ffffff;
+    --text-color: #2c3e50;
+    --border-color: #bdc3c7;
+    --success-color: #2ecc71;
+    --error-color: #e74c3c;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    background-color: var(--background-color);
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+header {
+    text-align: center;
+    margin-bottom: 30px;
+}
+
+header h1 {
+    color: var(--primary-color);
+}
+
+.main-content {
+    display: flex;
+    gap: 20px;
+    min-height: 80vh;
+}
+
+/* Sidebar */
+.sidebar {
+    flex-basis: 25%;
+    background-color: var(--card-background);
+    border-radius: 5px;
+    padding: 15px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
+
+.sidebar h2 {
+    margin-bottom: 15px;
+    font-size: 1.3rem;
+    color: var(--secondary-color);
+}
+
+.pod-list {
+    margin-top: 15px;
+}
+
+.pod-item {
+    padding: 10px;
+    margin-bottom: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+}
+
+.pod-item:hover {
+    background-color: #f5f7fa;
+}
+
+.pod-item.active {
+    background-color: #e1f0fa;
+    border-color: var(--primary-color);
+}
+
+/* Main Content */
+.content {
+    flex-basis: 75%;
+    background-color: var(--card-background);
+    border-radius: 5px;
+    padding: 20px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
+
+/* Tabs */
+.tabs {
+    display: flex;
+    border-bottom: 1px solid var(--border-color);
+    margin-bottom: 20px;
+}
+
+.tab-btn {
+    padding: 10px 20px;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 1rem;
+    color: var(--text-color);
+    opacity: 0.7;
+}
+
+.tab-btn:hover {
+    opacity: 1;
+}
+
+.tab-btn.active {
+    border-bottom: 3px solid var(--primary-color);
+    opacity: 1;
+    font-weight: bold;
+}
+
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+/* Forms */
+.form-group {
+    margin-bottom: 20px;
+}
+
+label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: bold;
+}
+
+input[type="text"],
+select {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 1rem;
+}
+
+/* Buttons */
+.btn {
+    padding: 8px 15px;
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 1rem;
+    transition: background-color 0.2s ease;
+}
+
+.btn:hover {
+    background-color: var(--secondary-color);
+}
+
+.submit-btn {
+    background-color: var(--success-color);
+    padding: 10px 20px;
+    font-size: 1.1rem;
+}
+
+.submit-btn:hover {
+    background-color: #27ae60;
+}
+
+/* Entry fields */
+.entry-row {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 10px;
+    align-items: center;
+}
+
+.entry-key {
+    flex: 2;
+}
+
+.entry-value {
+    flex: 3;
+}
+
+.entry-type {
+    flex: 1;
+}
+
+.remove-entry-btn {
+    background-color: var(--error-color);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 25px;
+    height: 25px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.8rem;
+}
+
+/* POD Details */
+.pod-details-container {
+    margin-top: 20px;
+}
+
+.pod-info {
+    margin-bottom: 20px;
+    padding: 15px;
+    background-color: #f8f9fa;
+    border-radius: 5px;
+}
+
+.pod-entries {
+    border: 1px solid var(--border-color);
+    border-radius: 5px;
+}
+
+.pod-entry {
+    display: flex;
+    padding: 10px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.pod-entry:last-child {
+    border-bottom: none;
+}
+
+.entry-name {
+    font-weight: bold;
+    width: 30%;
+}
+
+.entry-value-container {
+    width: 70%;
+}
+
+.select-message {
+    text-align: center;
+    color: #7f8c8d;
+    margin-top: 50px;
+}
+
+.sidebar-buttons {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    margin-bottom: 15px;
+}
+
+#refresh-pods-btn, #load-local-pods-btn {
+    width: 100%;
+}
+
+.btn-secondary {
+    background-color: #95a5a6;
+}
+
+.btn-secondary:hover {
+    background-color: #7f8c8d;
+}
+
+.btn-danger {
+    background-color: #e74c3c;
+}
+
+.btn-danger:hover {
+    background-color: #c0392b;
+}
+
+/* Status messages */
+.status-message {
+    padding: 10px;
+    margin: 10px 0;
+    border-radius: 4px;
+}
+
+.success {
+    background-color: #d1f8d9;
+    color: #196619;
+    border: 1px solid #99e699;
+}
+
+.error {
+    background-color: #f8d7da;
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+
+/* Visualization styles */
+.visualization-controls {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 20px;
+    align-items: center;
+}
+
+#visualization-container {
+    height: 500px;
+    border: 1px solid var(--border-color);
+    border-radius: 5px;
+    padding: 10px;
+    overflow: auto;
+    position: relative;
+}
+
+.node {
+    cursor: pointer;
+}
+
+.node circle {
+    fill: var(--primary-color);
+    stroke: var(--secondary-color);
+    stroke-width: 1.5px;
+}
+
+.node text {
+    font-size: 12px;
+    font-family: sans-serif;
+}
+
+.link {
+    fill: none;
+    stroke: #ccc;
+    stroke-width: 1.5px;
+}
+
+.node-label {
+    font-size: 10px;
+}
+
+svg {
+    width: 100%;
+    height: 100%;
+    display: block;
+}
+
+.tooltip {
+    position: absolute;
+    padding: 8px;
+    background: rgba(255, 255, 255, 0.9);
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    pointer-events: none;
+    font-size: 12px;
+    z-index: 1000;
+    max-width: 300px;
+}
+
+.json-container {
+    font-family: monospace;
+    white-space: pre-wrap;
+    font-size: 13px;
+    line-height: 1.4;
+}
+
+.json-key {
+    color: #881391;
+}
+
+.json-value-string {
+    color: #1a5723;
+}
+
+.json-value-number {
+    color: #0000ff;
+}
+
+.json-value-boolean {
+    color: #0000ff;
+}
+
+.json-bracket {
+    color: #555;
+}
+
+.node-details {
+    position: absolute;
+    right: 10px;
+    top: 10px;
+    width: 250px;
+    background: white;
+    border: 1px solid var(--border-color);
+    border-radius: 5px;
+    padding: 10px;
+    z-index: 100;
+    font-size: 12px;
+    max-height: 300px;
+    overflow-y: auto;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
\ No newline at end of file
diff --git a/static/index.html b/static/index.html
new file mode 100644
index 00000000..271f2a19
--- /dev/null
+++ b/static/index.html
@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>POD2 Viewer</title>
+    <link rel="stylesheet" href="css/style.css">
+    <!-- Add D3.js for visualizations -->
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+    <script src="js/app.js" defer></script>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>POD2 Viewer</h1>
+        </header>
+        
+        <div class="main-content">
+            <!-- Left Sidebar: POD List -->
+            <div class="sidebar">
+                <h2>Stored PODs</h2>
+                <div class="sidebar-buttons">
+                    <button id="refresh-pods-btn" class="btn">Refresh from Server</button>
+                    <button id="load-local-pods-btn" class="btn btn-secondary">Load from Local Storage</button>
+                    <button id="clear-storage-btn" class="btn btn-danger">Clear Storage</button>
+                </div>
+                <div id="pod-list" class="pod-list">
+                    <!-- POD items will be loaded here -->
+                </div>
+            </div>
+            
+            <!-- Main Panel: POD Viewer/Creator -->
+            <div class="content">
+                <div class="tabs">
+                    <button class="tab-btn active" data-tab="view-pod">View POD</button>
+                    <button class="tab-btn" data-tab="create-pod">Create POD</button>
+                    <button class="tab-btn" data-tab="visualize-pod">Visualize</button>
+                </div>
+                
+                <!-- View POD Tab -->
+                <div id="view-pod" class="tab-content active">
+                    <div id="pod-details">
+                        <p class="select-message">Select a POD from the sidebar to view details</p>
+                    </div>
+                </div>
+                
+                <!-- Create POD Tab -->
+                <div id="create-pod" class="tab-content">
+                    <h2>Create a Signed POD</h2>
+                    <form id="create-pod-form">
+                        <div class="form-group">
+                            <label for="signer">Signer:</label>
+                            <input type="text" id="signer" name="signer" required>
+                        </div>
+                        
+                        <div class="form-group">
+                            <h3>Entries</h3>
+                            <div id="entries-container">
+                                <!-- Dynamic entries will be added here -->
+                                <div class="entry-row">
+                                    <input type="text" class="entry-key" placeholder="Key" required>
+                                    <input type="text" class="entry-value" placeholder="Value" required>
+                                    <select class="entry-type">
+                                        <option value="string">String</option>
+                                        <option value="int">Integer</option>
+                                        <option value="bool">Boolean</option>
+                                    </select>
+                                    <button type="button" class="remove-entry-btn">✕</button>
+                                </div>
+                            </div>
+                            <button type="button" id="add-entry-btn" class="btn">Add Entry</button>
+                        </div>
+                        
+                        <button type="submit" class="btn submit-btn">Create POD</button>
+                    </form>
+                </div>
+                
+                <!-- Visualize POD Tab -->
+                <div id="visualize-pod" class="tab-content">
+                    <h2>POD Visualization</h2>
+                    <div class="visualization-controls">
+                        <button id="visualize-all-pods-btn" class="btn">Visualize All PODs</button>
+                        <select id="visualization-type">
+                            <option value="tree">Tree View</option>
+                            <option value="network">Network View</option>
+                            <option value="json">JSON Structure</option>
+                        </select>
+                    </div>
+                    <div id="visualization-container">
+                        <p class="select-message">Select a visualization type and click "Visualize All PODs"</p>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</body>
+</html>
\ No newline at end of file
diff --git a/static/js/app.js b/static/js/app.js
new file mode 100644
index 00000000..66ff6184
--- /dev/null
+++ b/static/js/app.js
@@ -0,0 +1,1069 @@
+// Application state
+let pods = [];
+let selectedPodId = null;
+let podDetailsCache = {}; // Cache for POD details
+
+// LocalStorage keys
+const PODS_STORAGE_KEY = 'pod2_pods';
+const SELECTED_POD_STORAGE_KEY = 'pod2_selected_pod';
+const POD_DETAILS_CACHE_KEY = 'pod2_pod_details_cache';
+
+// DOM elements
+const refreshBtn = document.getElementById('refresh-pods-btn');
+const loadLocalPodsBtn = document.getElementById('load-local-pods-btn');
+const clearStorageBtn = document.getElementById('clear-storage-btn');
+const podList = document.getElementById('pod-list');
+const podDetails = document.getElementById('pod-details');
+const tabButtons = document.querySelectorAll('.tab-btn');
+const tabContents = document.querySelectorAll('.tab-content');
+const createPodForm = document.getElementById('create-pod-form');
+const addEntryBtn = document.getElementById('add-entry-btn');
+const entriesContainer = document.getElementById('entries-container');
+const visualizeAllPodsBtn = document.getElementById('visualize-all-pods-btn');
+const visualizationType = document.getElementById('visualization-type');
+const visualizationContainer = document.getElementById('visualization-container');
+
+// API endpoints
+const API_BASE_URL = '/api';
+const API_PODS = `${API_BASE_URL}/pods`;
+
+// Functions for local storage
+function savePods() {
+    try {
+        if (Array.isArray(pods) && pods.length > 0) {
+            localStorage.setItem(PODS_STORAGE_KEY, JSON.stringify(pods));
+            console.log('Saved pods to localStorage:', pods);
+        } else {
+            console.warn('Not saving pods to localStorage because the array is empty');
+        }
+    } catch (error) {
+        console.error('Error saving pods to localStorage:', error);
+    }
+}
+
+function saveSelectedPod() {
+    try {
+        localStorage.setItem(SELECTED_POD_STORAGE_KEY, selectedPodId);
+    } catch (error) {
+        console.error('Error saving selected pod to localStorage:', error);
+    }
+}
+
+function loadPodsFromStorage() {
+    try {
+        const storedPods = localStorage.getItem(PODS_STORAGE_KEY);
+        if (storedPods) {
+            const parsedPods = JSON.parse(storedPods);
+            // Make sure we have a valid array of pods
+            if (Array.isArray(parsedPods) && parsedPods.length > 0) {
+                pods = parsedPods;
+                console.log('Loaded pods from localStorage:', pods);
+                return true;
+            }
+        }
+    } catch (error) {
+        console.error('Error loading pods from localStorage:', error);
+    }
+    return false;
+}
+
+function loadSelectedPodFromStorage() {
+    try {
+        const storedSelectedPod = localStorage.getItem(SELECTED_POD_STORAGE_KEY);
+        if (storedSelectedPod) {
+            selectedPodId = storedSelectedPod;
+            return true;
+        }
+    } catch (error) {
+        console.error('Error loading selected pod from localStorage:', error);
+    }
+    return false;
+}
+
+function savePodDetailsCache() {
+    try {
+        if (typeof podDetailsCache === 'object' && podDetailsCache !== null && Object.keys(podDetailsCache).length > 0) {
+            localStorage.setItem(POD_DETAILS_CACHE_KEY, JSON.stringify(podDetailsCache));
+            console.log('Saved pod details cache to localStorage:', Object.keys(podDetailsCache));
+        } else {
+            console.warn('Not saving pod details cache to localStorage because it is empty');
+        }
+    } catch (error) {
+        console.error('Error saving pod details cache to localStorage:', error);
+    }
+}
+
+function loadPodDetailsCacheFromStorage() {
+    try {
+        const storedCache = localStorage.getItem(POD_DETAILS_CACHE_KEY);
+        if (storedCache) {
+            const parsedCache = JSON.parse(storedCache);
+            // Make sure we have a valid object with at least one key
+            if (typeof parsedCache === 'object' && parsedCache !== null && Object.keys(parsedCache).length > 0) {
+                podDetailsCache = parsedCache;
+                console.log('Loaded pod details cache from localStorage:', Object.keys(podDetailsCache));
+                return true;
+            }
+        }
+    } catch (error) {
+        console.error('Error loading pod details cache from localStorage:', error);
+    }
+    return false;
+}
+
+// Event listeners
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('DOM loaded, checking localStorage');
+    
+    // Try to load pods from local storage first
+    const podsLoaded = loadPodsFromStorage();
+    const cacheLoaded = loadPodDetailsCacheFromStorage();
+    const selectedPodLoaded = loadSelectedPodFromStorage();
+    
+    console.log('Storage check results:', {
+        podsLoaded,
+        cacheLoaded,
+        selectedPodLoaded,
+        selectedPodId,
+        hasPodDetailsForSelected: selectedPodId && podDetailsCache[selectedPodId]
+    });
+    
+    if (podsLoaded) {
+        renderPodList();
+        
+        // If we have a selected pod with details, render it
+        if (selectedPodId && cacheLoaded && podDetailsCache[selectedPodId]) {
+            console.log('Rendering cached pod details for:', selectedPodId);
+            renderPodDetails(podDetailsCache[selectedPodId]);
+        } else if (selectedPodId) {
+            console.log('Fetching pod details from server for:', selectedPodId);
+            loadPodDetails(selectedPodId);
+        }
+    } else {
+        // If no pods in local storage, fetch from server
+        console.log('No pods in localStorage, fetching from server');
+        loadPods();
+    }
+    
+    // Tab switching
+    tabButtons.forEach(button => {
+        button.addEventListener('click', () => {
+            // Deactivate all tabs
+            tabButtons.forEach(btn => btn.classList.remove('active'));
+            tabContents.forEach(content => content.classList.remove('active'));
+            
+            // Activate selected tab
+            button.classList.add('active');
+            const tabId = button.getAttribute('data-tab');
+            document.getElementById(tabId).classList.add('active');
+        });
+    });
+    
+    // Refresh pods button (from server)
+    refreshBtn.addEventListener('click', () => {
+        // Clear the cache when refreshing from server
+        podDetailsCache = {};
+        localStorage.removeItem(POD_DETAILS_CACHE_KEY);
+        
+        // Load pods from server
+        loadPods();
+    });
+    
+    // Load from local storage button
+    loadLocalPodsBtn.addEventListener('click', () => {
+        if (loadPodsFromStorage() && loadPodDetailsCacheFromStorage()) {
+            renderPodList();
+            
+            // If there's a selected pod, load its details
+            if (loadSelectedPodFromStorage() && selectedPodId && podDetailsCache[selectedPodId]) {
+                renderPodDetails(podDetailsCache[selectedPodId]);
+            }
+            
+            showStatusMessage('Loaded PODs from local storage', 'success');
+        } else {
+            showStatusMessage('No PODs found in local storage', 'error');
+        }
+    });
+    
+    // Clear storage button
+    clearStorageBtn.addEventListener('click', () => {
+        if (confirm('Are you sure you want to clear all local storage data?')) {
+            localStorage.removeItem(PODS_STORAGE_KEY);
+            localStorage.removeItem(SELECTED_POD_STORAGE_KEY);
+            localStorage.removeItem(POD_DETAILS_CACHE_KEY);
+            
+            // Reset application state
+            pods = [];
+            selectedPodId = null;
+            podDetailsCache = {};
+            
+            // Clear UI
+            renderPodList();
+            podDetails.innerHTML = '<p class="select-message">Select a POD from the sidebar to view details</p>';
+            
+            showStatusMessage('Local storage cleared successfully', 'success');
+        }
+    });
+    
+    // Add entry button
+    addEntryBtn.addEventListener('click', addEntryRow);
+    
+    // Remove entry button delegation
+    entriesContainer.addEventListener('click', (e) => {
+        if (e.target.classList.contains('remove-entry-btn')) {
+            // Don't remove the last entry row
+            if (entriesContainer.children.length > 1) {
+                e.target.closest('.entry-row').remove();
+            }
+        }
+    });
+    
+    // Create POD form
+    createPodForm.addEventListener('submit', handleCreatePod);
+    
+    // Visualization button
+    visualizeAllPodsBtn.addEventListener('click', handleVisualizePods);
+});
+
+// Load PODs from the API
+async function loadPods() {
+    try {
+        const response = await fetch(API_PODS);
+        const data = await response.json();
+        
+        pods = data.pods || [];
+        console.log('Loaded pods from API:', pods);
+        
+        // Save to local storage if not empty
+        if (pods.length > 0) {
+            savePods();
+        } else {
+            console.log('No pods loaded from API');
+        }
+        
+        renderPodList();
+    } catch (error) {
+        console.error('Error loading pods:', error);
+        showStatusMessage('Failed to load PODs', 'error');
+    }
+}
+
+// Render the POD list in the sidebar
+function renderPodList() {
+    podList.innerHTML = '';
+    
+    if (pods.length === 0) {
+        podList.innerHTML = '<p>No PODs available</p>';
+        return;
+    }
+    
+    pods.forEach(pod => {
+        const podItem = document.createElement('div');
+        podItem.className = 'pod-item';
+        
+        // Highlight the selected POD
+        if (pod.id === selectedPodId) {
+            podItem.classList.add('active');
+        }
+        
+        podItem.innerHTML = `
+            <div><strong>ID:</strong> ${truncateText(pod.id, 12)}</div>
+            <div><strong>Signer:</strong> ${pod.signer}</div>
+        `;
+        
+        podItem.addEventListener('click', () => {
+            selectedPodId = pod.id;
+            
+            // Save selected POD to local storage
+            saveSelectedPod();
+            
+            loadPodDetails(pod.id);
+            
+            // Update active class
+            document.querySelectorAll('.pod-item').forEach(item => {
+                item.classList.remove('active');
+            });
+            podItem.classList.add('active');
+            
+            // Switch to view tab
+            tabButtons.forEach(btn => btn.classList.remove('active'));
+            tabContents.forEach(content => content.classList.remove('active'));
+            document.querySelector('[data-tab="view-pod"]').classList.add('active');
+            document.getElementById('view-pod').classList.add('active');
+        });
+        
+        podList.appendChild(podItem);
+    });
+}
+
+// Load POD details from the API
+async function loadPodDetails(podId) {
+    try {
+        // Check if we have the pod details cached
+        if (podDetailsCache[podId]) {
+            renderPodDetails(podDetailsCache[podId]);
+            return;
+        }
+        
+        const response = await fetch(`${API_PODS}/${podId}`);
+        
+        if (!response.ok) {
+            throw new Error('Failed to load POD details');
+        }
+        
+        const pod = await response.json();
+        
+        // Cache the pod details
+        podDetailsCache[podId] = pod;
+        savePodDetailsCache();
+        
+        renderPodDetails(pod);
+    } catch (error) {
+        console.error('Error loading pod details:', error);
+        showStatusMessage('Failed to load POD details', 'error');
+    }
+}
+
+// Render POD details in the main panel
+function renderPodDetails(pod) {
+    // Convert pod entries to array for easier rendering
+    const entriesArray = Object.entries(pod.entries).map(([key, value]) => ({
+        key,
+        value: formatPodValue(value)
+    }));
+    
+    podDetails.innerHTML = `
+        <div class="pod-details-container">
+            <div class="pod-info">
+                <h2>POD Details</h2>
+                <p><strong>ID:</strong> ${pod.id}</p>
+                <p><strong>Class:</strong> ${pod.pod_class}</p>
+                <p><strong>Signer:</strong> ${pod.signer}</p>
+                <p><strong>Valid:</strong> ${pod.is_valid ? 'Yes ✓' : 'No ✗'}</p>
+            </div>
+            
+            <h3>Entries</h3>
+            <div class="pod-entries">
+                ${entriesArray.map(entry => `
+                    <div class="pod-entry">
+                        <div class="entry-name">${entry.key}</div>
+                        <div class="entry-value-container">${entry.value}</div>
+                    </div>
+                `).join('')}
+            </div>
+        </div>
+    `;
+}
+
+// Format POD values for display - this function is now replaced by the more
+// flexible formatPodValue function with includeHtml parameter
+function formatPodValue(value, includeHtml = true) {
+    if (value === null || value === undefined) {
+        return includeHtml ? '<em>null</em>' : 'null';
+    }
+    
+    if (typeof value === 'object') {
+        if ('Int' in value) {
+            return includeHtml 
+                ? `<span class="value-int">${value.Int}</span>` 
+                : `${value.Int}`;
+        }
+        if ('String' in value) {
+            return includeHtml 
+                ? `<span class="value-string">"${value.String}"</span>` 
+                : `"${value.String}"`;
+        }
+        if ('Bool' in value) {
+            return includeHtml 
+                ? `<span class="value-bool">${value.Bool}</span>` 
+                : `${value.Bool}`;
+        }
+        if ('Dictionary' in value) return includeHtml ? `<span class="value-dict">[Dictionary]</span>` : "[Dictionary]";
+        if ('Set' in value) return includeHtml ? `<span class="value-set">[Set]</span>` : "[Set]";
+        if ('Array' in value) return includeHtml ? `<span class="value-array">[Array]</span>` : "[Array]";
+        
+        // For raw values or other object types
+        return includeHtml 
+            ? `<pre>${JSON.stringify(value, null, 2)}</pre>` 
+            : JSON.stringify(value);
+    }
+    
+    return String(value);
+}
+
+// Add a new entry row to the create POD form
+function addEntryRow() {
+    const entryRow = document.createElement('div');
+    entryRow.className = 'entry-row';
+    entryRow.innerHTML = `
+        <input type="text" class="entry-key" placeholder="Key" required>
+        <input type="text" class="entry-value" placeholder="Value" required>
+        <select class="entry-type">
+            <option value="string">String</option>
+            <option value="int">Integer</option>
+            <option value="bool">Boolean</option>
+        </select>
+        <button type="button" class="remove-entry-btn">✕</button>
+    `;
+    
+    entriesContainer.appendChild(entryRow);
+}
+
+// Handle form submission to create a new POD
+async function handleCreatePod(e) {
+    e.preventDefault();
+    
+    const signer = document.getElementById('signer').value.trim();
+    const entryRows = entriesContainer.querySelectorAll('.entry-row');
+    
+    const entries = {};
+    for (const row of entryRows) {
+        const key = row.querySelector('.entry-key').value.trim();
+        const value = row.querySelector('.entry-value').value.trim();
+        const type = row.querySelector('.entry-type').value;
+        
+        if (!key || !value) {
+            showStatusMessage('All entries must have both key and value', 'error');
+            return;
+        }
+        
+        // Convert the value based on its type
+        let convertedValue;
+        switch (type) {
+            case 'int':
+                if (!/^-?\d+$/.test(value)) {
+                    showStatusMessage(`Value for key '${key}' is not a valid integer`, 'error');
+                    return;
+                }
+                convertedValue = parseInt(value, 10);
+                break;
+            case 'bool':
+                if (value.toLowerCase() !== 'true' && value.toLowerCase() !== 'false') {
+                    showStatusMessage(`Value for key '${key}' is not a valid boolean (true/false)`, 'error');
+                    return;
+                }
+                convertedValue = value.toLowerCase() === 'true';
+                break;
+            default: // string
+                convertedValue = value;
+        }
+        
+        entries[key] = convertedValue;
+    }
+    
+    try {
+        const response = await fetch(API_PODS, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                signer,
+                entries
+            })
+        });
+        
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.error || 'Failed to create POD');
+        }
+        
+        const data = await response.json();
+        showStatusMessage(`POD created successfully with ID: ${data.id}`, 'success');
+        
+        // Reset form
+        createPodForm.reset();
+        entriesContainer.innerHTML = '';
+        addEntryRow(); // Add one empty row
+        
+        // After creating a new pod, fetch the pod details
+        const podResponse = await fetch(`${API_PODS}/${data.id}`);
+        const podData = await podResponse.json();
+        
+        // Add the new pod to the list and save to localStorage
+        const newPod = {
+            id: podData.id,
+            pod_class: podData.pod_class,
+            signer: podData.signer,
+            created_at: podData.created_at
+        };
+        
+        console.log('Adding new pod to array:', newPod);
+        
+        // Make sure pods is an array
+        if (!Array.isArray(pods)) {
+            pods = [];
+        }
+        
+        pods.push(newPod);
+        console.log('Pods array after adding:', pods);
+        savePods();
+        
+        // Cache the pod details
+        podDetailsCache[podData.id] = podData;
+        savePodDetailsCache();
+        
+        // Select the new pod
+        selectedPodId = data.id;
+        saveSelectedPod();
+        
+        // Render the updated list
+        renderPodList();
+        
+        // Load and show the new pod details
+        renderPodDetails(podData);
+        
+        // Switch to view tab
+        tabButtons.forEach(btn => btn.classList.remove('active'));
+        tabContents.forEach(content => content.classList.remove('active'));
+        document.querySelector('[data-tab="view-pod"]').classList.add('active');
+        document.getElementById('view-pod').classList.add('active');
+        
+    } catch (error) {
+        console.error('Error creating pod:', error);
+        showStatusMessage(error.message, 'error');
+    }
+}
+
+// Helper to show status messages
+function showStatusMessage(message, type = 'success') {
+    const existingMessage = document.querySelector('.status-message');
+    if (existingMessage) {
+        existingMessage.remove();
+    }
+    
+    const messageElement = document.createElement('div');
+    messageElement.className = `status-message ${type}`;
+    messageElement.textContent = message;
+    
+    const currentTab = document.querySelector('.tab-content.active');
+    currentTab.insertAdjacentElement('afterbegin', messageElement);
+    
+    // Auto-remove after 5 seconds
+    setTimeout(() => {
+        if (messageElement.parentNode) {
+            messageElement.remove();
+        }
+    }, 5000);
+}
+
+// Helper to truncate text with ellipsis
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return text.substring(0, maxLength) + '...';
+}
+
+// Handle visualization of pods
+async function handleVisualizePods() {
+    try {
+        // First check if we have pods in memory
+        if (pods.length === 0) {
+            // Try loading from storage first
+            if (!loadPodsFromStorage()) {
+                // If nothing in storage, try from server
+                await loadPods();
+            }
+        }
+        
+        console.log('Visualization - current pods:', pods);
+        
+        if (pods.length === 0) {
+            visualizationContainer.innerHTML = '<p>No PODs available to visualize</p>';
+            return;
+        }
+        
+        // Make sure pod details cache is loaded
+        if (Object.keys(podDetailsCache).length === 0) {
+            loadPodDetailsCacheFromStorage();
+        }
+        
+        console.log('Visualization - pod details cache:', Object.keys(podDetailsCache));
+        
+        // Fetch full pod details for all pods, using cache when available
+        const podDetails = await Promise.all(
+            pods.map(async pod => {
+                try {
+                    console.log(`Getting details for pod ${pod.id}`);
+                    
+                    if (podDetailsCache[pod.id]) {
+                        console.log(`Using cached details for pod ${pod.id}`);
+                        return podDetailsCache[pod.id];
+                    } else {
+                        console.log(`Fetching details for pod ${pod.id} from server`);
+                        try {
+                            const response = await fetch(`${API_PODS}/${pod.id}`);
+                            if (!response.ok) {
+                                throw new Error(`Server returned ${response.status} ${response.statusText}`);
+                            }
+                            
+                            const data = await response.json();
+                            
+                            // Cache the result
+                            podDetailsCache[pod.id] = data;
+                            savePodDetailsCache();
+                            
+                            return data;
+                        } catch (fetchError) {
+                            console.error(`Error fetching pod ${pod.id}:`, fetchError);
+                            // Return a basic structure to avoid breaking the visualization
+                            return {
+                                id: pod.id,
+                                pod_class: pod.pod_class || 'Unknown',
+                                signer: pod.signer || 'Unknown',
+                                entries: {},
+                                is_valid: false
+                            };
+                        }
+                    }
+                } catch (podError) {
+                    console.error(`Error handling pod ${pod.id}:`, podError);
+                    // Return a placeholder for failed pods
+                    return {
+                        id: pod.id,
+                        pod_class: 'Error',
+                        signer: 'Error',
+                        entries: { error: `Failed to load: ${podError.message}` },
+                        is_valid: false
+                    };
+                }
+            })
+        );
+        
+        console.log('Visualization - got pod details:', podDetails);
+        
+        const type = visualizationType.value;
+        
+        // Clear the container
+        visualizationContainer.innerHTML = '';
+        
+        switch (type) {
+            case 'tree':
+                renderTreeVisualization(podDetails);
+                break;
+            case 'network':
+                renderNetworkVisualization(podDetails);
+                break;
+            case 'json':
+                renderJsonVisualization(podDetails);
+                break;
+            default:
+                visualizationContainer.innerHTML = '<p>Unknown visualization type</p>';
+        }
+    } catch (error) {
+        console.error('Error visualizing pods:', error);
+        showStatusMessage('Failed to visualize PODs', 'error');
+    }
+}
+
+// Render a tree visualization using D3.js
+function renderTreeVisualization(podDetails) {
+    try {
+        // Create a hierarchical structure for the tree
+        const root = {
+            name: "PODs",
+            children: podDetails.map(pod => {
+                try {
+                    return {
+                        name: truncateText(pod.id, 8),
+                        signer: pod.signer || 'Unknown',
+                        id: pod.id,
+                        children: Object.entries(pod.entries || {}).map(([key, value]) => {
+                            try {
+                                return {
+                                    name: key,
+                                    value: formatPodValue(value, false),
+                                    pod_id: pod.id
+                                };
+                            } catch (entryError) {
+                                console.warn(`Error processing entry ${key}:`, entryError);
+                                return {
+                                    name: key,
+                                    value: '[Error processing value]',
+                                    pod_id: pod.id
+                                };
+                            }
+                        })
+                    };
+                } catch (podError) {
+                    console.warn(`Error processing pod ${pod.id}:`, podError);
+                    return {
+                        name: truncateText(pod.id, 8),
+                        signer: 'Error',
+                        id: pod.id,
+                        children: [{ 
+                            name: 'error', 
+                            value: `Error processing: ${podError.message}`,
+                            pod_id: pod.id
+                        }]
+                    };
+                }
+            })
+        };
+        
+        // Set up the visualization dimensions
+        const width = visualizationContainer.clientWidth;
+        const height = visualizationContainer.clientHeight;
+        const margin = { top: 20, right: 120, bottom: 20, left: 120 };
+        
+        // Create SVG element
+        const svg = d3.select(visualizationContainer)
+            .append("svg")
+            .attr("width", width)
+            .attr("height", height)
+            .append("g")
+            .attr("transform", `translate(${margin.left},${margin.top})`);
+        
+        // Create the tree layout
+        const tree = d3.tree().size([height - margin.top - margin.bottom, width - margin.left - margin.right]);
+        
+        // Assign hierarchy to data
+        const hierarchyRoot = d3.hierarchy(root);
+        
+        // Compute the tree layout
+        const treeData = tree(hierarchyRoot);
+        
+        // Add links between nodes
+        svg.selectAll(".link")
+            .data(treeData.links())
+            .enter()
+            .append("path")
+            .attr("class", "link")
+            .attr("d", d3.linkHorizontal()
+                .x(d => d.y)
+                .y(d => d.x));
+        
+        // Add nodes
+        const node = svg.selectAll(".node")
+            .data(treeData.descendants())
+            .enter()
+            .append("g")
+            .attr("class", d => "node" + (d.children ? " node--internal" : " node--leaf"))
+            .attr("transform", d => `translate(${d.y},${d.x})`);
+        
+        // Add circles to nodes
+        node.append("circle")
+            .attr("r", 5)
+            .style("fill", d => {
+                if (d.depth === 0) return "#999"; // Root
+                if (d.depth === 1) return "#3498db"; // POD
+                return "#2ecc71"; // Entry
+            });
+        
+        // Add labels to nodes
+        node.append("text")
+            .attr("dy", ".35em")
+            .attr("x", d => d.children ? -10 : 10)
+            .style("text-anchor", d => d.children ? "end" : "start")
+            .text(d => d.data.name)
+            .append("tspan")
+            .attr("class", "node-label")
+            .attr("x", d => d.children ? -10 : 10)
+            .attr("dy", "1.2em")
+            .text(d => {
+                try {
+                    if (d.depth === 1 && d.data.signer) {
+                        return `Signer: ${d.data.signer}`;
+                    }
+                    if (d.depth === 2 && d.data.value) {
+                        return `Value: ${d.data.value}`;
+                    }
+                    return "";
+                } catch (error) {
+                    console.warn('Error generating label:', error);
+                    return "[Error]";
+                }
+            });
+        
+        // Add tooltip for more info on hover
+        const tooltip = d3.select(visualizationContainer)
+            .append("div")
+            .attr("class", "tooltip")
+            .style("opacity", 0);
+        
+        node.on("mouseover", function(event, d) {
+            try {
+                if (d.depth >= 1) { // Only show tooltip for PODs and entries
+                    tooltip.transition()
+                        .duration(200)
+                        .style("opacity", .9);
+                    
+                    let tooltipContent = "";
+                    if (d.depth === 1) {
+                        tooltipContent = `
+                            <strong>POD ID:</strong> ${d.data.id}<br>
+                            <strong>Signer:</strong> ${d.data.signer}<br>
+                            <strong>Entries:</strong> ${d.data.children ? d.data.children.length : 0}
+                        `;
+                    } else if (d.depth === 2) {
+                        tooltipContent = `
+                            <strong>Key:</strong> ${d.data.name}<br>
+                            <strong>Value:</strong> ${d.data.value || '[No value]'}<br>
+                            <strong>POD ID:</strong> ${d.data.pod_id || '[Unknown]'}
+                        `;
+                    }
+                    
+                    tooltip.html(tooltipContent)
+                        .style("left", (event.pageX - visualizationContainer.getBoundingClientRect().left + 10) + "px")
+                        .style("top", (event.pageY - visualizationContainer.getBoundingClientRect().top - 28) + "px");
+                }
+            } catch (error) {
+                console.warn('Error showing tooltip:', error);
+            }
+        })
+        .on("mouseout", function() {
+            tooltip.transition()
+                .duration(500)
+                .style("opacity", 0);
+        });
+    } catch (error) {
+        console.error('Error rendering tree visualization:', error);
+        visualizationContainer.innerHTML = `<div class="error">Error rendering tree visualization: ${error.message}</div>`;
+    }
+}
+
+// Render a network visualization using D3.js
+function renderNetworkVisualization(podDetails) {
+    try {
+        // Create nodes and links for the network
+        const nodes = [];
+        const links = [];
+        
+        // Add POD nodes
+        podDetails.forEach(pod => {
+            try {
+                nodes.push({
+                    id: pod.id,
+                    group: 1, // POD group
+                    signer: pod.signer || 'Unknown',
+                    type: "pod"
+                });
+                
+                // Add entry nodes and links to POD
+                Object.entries(pod.entries || {}).forEach(([key, value]) => {
+                    try {
+                        const entryId = `${pod.id}-${key}`;
+                        nodes.push({
+                            id: entryId,
+                            group: 2, // Entry group
+                            key: key,
+                            value: formatPodValue(value, false),
+                            type: "entry"
+                        });
+                        
+                        links.push({
+                            source: pod.id,
+                            target: entryId,
+                            value: 1
+                        });
+                    } catch (entryError) {
+                        console.warn(`Error processing entry ${key}:`, entryError);
+                    }
+                });
+            } catch (podError) {
+                console.warn(`Error processing pod ${pod.id}:`, podError);
+            }
+        });
+    
+        // Set up the visualization dimensions
+        const width = visualizationContainer.clientWidth;
+        const height = visualizationContainer.clientHeight;
+        
+        // Create SVG element
+        const svg = d3.select(visualizationContainer)
+            .append("svg")
+            .attr("width", width)
+            .attr("height", height);
+        
+        if (nodes.length === 0) {
+            visualizationContainer.innerHTML = '<p>No valid POD data to visualize</p>';
+            return;
+        }
+        
+        // Define the forces for the simulation
+        const simulation = d3.forceSimulation(nodes)
+            .force("link", d3.forceLink(links).id(d => d.id).distance(100))
+            .force("charge", d3.forceManyBody().strength(-300))
+            .force("center", d3.forceCenter(width / 2, height / 2))
+            .force("x", d3.forceX(width / 2))
+            .force("y", d3.forceY(height / 2));
+        
+        // Add links
+        const link = svg.append("g")
+            .selectAll("line")
+            .data(links)
+            .enter()
+            .append("line")
+            .attr("class", "link");
+        
+        // Add node groups
+        const node = svg.append("g")
+            .selectAll("g")
+            .data(nodes)
+            .enter()
+            .append("g")
+            .attr("class", "node")
+            .call(d3.drag()
+                .on("start", dragStarted)
+                .on("drag", dragged)
+                .on("end", dragEnded));
+        
+        // Add circles to nodes
+        node.append("circle")
+            .attr("r", d => d.type === "pod" ? 10 : 5)
+            .style("fill", d => d.type === "pod" ? "#3498db" : "#2ecc71");
+        
+        // Add labels to nodes
+        node.append("text")
+            .attr("dy", ".35em")
+            .attr("x", d => d.type === "pod" ? 12 : 8)
+            .text(d => {
+                try {
+                    if (d.type === "pod") {
+                        return truncateText(d.id, 8);
+                    } else {
+                        return d.key;
+                    }
+                } catch (error) {
+                    console.warn('Error rendering node label:', error);
+                    return '[Error]';
+                }
+            });
+        
+        // Add tooltip for more info on hover
+        const tooltip = d3.select(visualizationContainer)
+            .append("div")
+            .attr("class", "tooltip")
+            .style("opacity", 0);
+        
+        node.on("mouseover", function(event, d) {
+            try {
+                tooltip.transition()
+                    .duration(200)
+                    .style("opacity", .9);
+                
+                let tooltipContent = "";
+                if (d.type === "pod") {
+                    tooltipContent = `
+                        <strong>POD ID:</strong> ${d.id}<br>
+                        <strong>Signer:</strong> ${d.signer || 'Unknown'}
+                    `;
+                } else {
+                    tooltipContent = `
+                        <strong>Key:</strong> ${d.key || 'Unknown'}<br>
+                        <strong>Value:</strong> ${d.value || 'Unknown'}
+                    `;
+                }
+                
+                tooltip.html(tooltipContent)
+                    .style("left", (event.pageX - visualizationContainer.getBoundingClientRect().left + 10) + "px")
+                    .style("top", (event.pageY - visualizationContainer.getBoundingClientRect().top - 28) + "px");
+            } catch (error) {
+                console.warn('Error showing tooltip:', error);
+            }
+        })
+        .on("mouseout", function() {
+            tooltip.transition()
+                .duration(500)
+                .style("opacity", 0);
+        });
+        
+        // Update positions during simulation
+        simulation.on("tick", () => {
+            link
+                .attr("x1", d => d.source.x)
+                .attr("y1", d => d.source.y)
+                .attr("x2", d => d.target.x)
+                .attr("y2", d => d.target.y);
+            
+            node
+                .attr("transform", d => `translate(${d.x},${d.y})`);
+        });
+        
+        // Drag functions
+        function dragStarted(event, d) {
+            if (!event.active) simulation.alphaTarget(0.3).restart();
+            d.fx = d.x;
+            d.fy = d.y;
+        }
+        
+        function dragged(event, d) {
+            d.fx = event.x;
+            d.fy = event.y;
+        }
+        
+        function dragEnded(event, d) {
+            if (!event.active) simulation.alphaTarget(0);
+            d.fx = null;
+            d.fy = null;
+        }
+    } catch (error) {
+        console.error('Error rendering network visualization:', error);
+        visualizationContainer.innerHTML = `<div class="error">Error rendering network visualization: ${error.message}</div>`;
+    }
+}
+
+// Render a JSON tree visualization
+function renderJsonVisualization(podDetails) {
+    const jsonContainer = document.createElement('div');
+    jsonContainer.className = 'json-container';
+    
+    // Format the JSON for display
+    const formattedJson = formatJsonForDisplay(podDetails);
+    jsonContainer.innerHTML = formattedJson;
+    
+    visualizationContainer.appendChild(jsonContainer);
+}
+
+// The formatPodValue function has been moved up earlier in the code
+
+// Format JSON for display with syntax highlighting
+function formatJsonForDisplay(json) {
+    try {
+        // Use replacer function to handle circular references
+        const getCircularReplacer = () => {
+            const seen = new WeakSet();
+            return (key, value) => {
+                if (typeof value === 'object' && value !== null) {
+                    if (seen.has(value)) {
+                        return '[Circular Reference]';
+                    }
+                    seen.add(value);
+                }
+                return value;
+            };
+        };
+        
+        // Try to stringify with circular reference handler
+        const jsonString = JSON.stringify(json, getCircularReplacer(), 2);
+        
+        if (!jsonString) {
+            return '<div class="error">Failed to format JSON data</div>';
+        }
+        
+        // Basic syntax highlighting
+        return jsonString
+            .replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, match => {
+                let cls = 'json-value-number';
+                if (/^"/.test(match)) {
+                    if (/:$/.test(match)) {
+                        cls = 'json-key';
+                        match = match.replace(/:$/, '');
+                    } else {
+                        cls = 'json-value-string';
+                    }
+                } else if (/true|false/.test(match)) {
+                    cls = 'json-value-boolean';
+                } else if (/null/.test(match)) {
+                    cls = 'json-value-null';
+                }
+                
+                return `<span class="${cls}">${match}</span>`;
+            })
+            .replace(/[{}[\],]/g, match => {
+                return `<span class="json-bracket">${match}</span>`;
+            });
+    } catch (error) {
+        console.error('Error in formatJsonForDisplay:', error);
+        return `<div class="error">Error formatting JSON: ${error.message}</div>`;
+    }
+}
\ No newline at end of file