diff --git a/nested-routes.cabal b/nested-routes.cabal
--- a/nested-routes.cabal
+++ b/nested-routes.cabal
@@ -1,5 +1,5 @@
 Name:                   nested-routes
-Version:                0.0.2
+Version:                0.0.3.1
 Author:                 Athan Clark <athan.clark@gmail.com>
 Maintainer:             Athan Clark <athan.clark@gmail.com>
 License:                BSD3
@@ -24,7 +24,7 @@
                       , transformers
                       , semigroups
                       , containers
-                      , pseudo-trie >= 0.0.4
+                      , pseudo-trie >= 0.0.4.2
                       , text
                       , aeson
                       , blaze-html
diff --git a/src/Web/Routes/Nested.hs b/src/Web/Routes/Nested.hs
--- a/src/Web/Routes/Nested.hs
+++ b/src/Web/Routes/Nested.hs
@@ -25,38 +25,54 @@
 import           Control.Monad.IO.Class
 import           Control.Monad.Trans
 import           Control.Monad.Writer
+import           Control.Monad.Reader
 import qualified Data.List.NonEmpty                as NE
 import           Data.Monoid
 import           Data.Trie.Pseudo
+import qualified Data.Trie.Pseudo                  as P
 import           Data.Trie.Rooted
 import qualified Data.Trie.Rooted                  as R
 import           Data.Traversable
 import qualified Data.Text                         as T
 import qualified Data.Map.Lazy                     as M
+import qualified Data.ByteString.Lazy              as BL
 
 
 newtype HandlerT z m a = HandlerT
-  { runHandler :: WriterT (MergeRooted T.Text (Verbs z Response)) m a }
+  { runHandler :: WriterT (MergeRooted T.Text (Verbs z m Response)) m a }
   deriving (Functor)
 
 deriving instance Applicative m => Applicative (HandlerT z m)
 deriving instance Monad m =>       Monad       (HandlerT z m)
 deriving instance MonadIO m =>     MonadIO     (HandlerT z m)
-deriving instance                  MonadTrans  (HandlerT z)
+instance MonadTrans (HandlerT z) where
+  lift ma = HandlerT $ lift ma
 
 
 handle :: Monad m =>
           [T.Text]
        -> VerbListenerT z Response m ()
+       -> [HandlerT z m ()]
        -> HandlerT z m ()
-handle ts vl = do
+handle ts vl [] = do
   vfrs <- lift $ execWriterT $ runVerbListenerT vl
 
   HandlerT $ tell $
     case ts of
       [] -> MergeRooted $ Rooted (Just vfrs) []
       _  -> MergeRooted $ Rooted Nothing [Rest (NE.fromList ts) vfrs]
+handle ts vl cs = do
+  vfrs <- lift $ execWriterT $ runVerbListenerT vl
+  child <- lift $ foldM (\acc c -> (acc <>) <$> (execWriterT $ runHandler c)) mempty cs
 
+  HandlerT $ tell $
+    case ts of
+      [] -> case unMergeRooted child of
+              Rooted _ xs -> MergeRooted $ Rooted (Just vfrs) xs
+      _  -> let child' = push (unMergeRooted child) $ NE.fromList ts in
+            MergeRooted $ Rooted Nothing [P.assign (NE.fromList ts) (Just vfrs) child']
+
+
 route :: (Functor m, Monad m, MonadIO m) =>
          HandlerT z m a
       -> Request -> (Response -> m b) -> m b
@@ -78,7 +94,7 @@
                 Nothing    -> respond r
                 Just reqbf -> do
                   body <- liftIO $ strictRequestBody req
-                  return $ reqbf body
+                  (runReaderT $ reqbf) body
                   respond r
             Nothing -> respond notFound
         Nothing -> respond notFound
diff --git a/src/Web/Routes/Nested/VerbListener.hs b/src/Web/Routes/Nested/VerbListener.hs
--- a/src/Web/Routes/Nested/VerbListener.hs
+++ b/src/Web/Routes/Nested/VerbListener.hs
@@ -14,6 +14,7 @@
 import           Control.Applicative hiding (empty)
 import           Control.Monad.Trans
 import           Control.Monad.Writer
+import           Control.Monad.Reader
 import           Data.Monoid
 import           Data.Foldable
 import           Data.Traversable
@@ -27,22 +28,21 @@
           | Delete
   deriving (Show, Eq, Ord)
 
-type ReqBodyT z = BL.ByteString -> z
-
-newtype Verbs z a = Verbs { unVerbs :: Map Verb (Maybe (ReqBodyT z), FileExts a) }
+newtype Verbs z m r = Verbs { unVerbs :: Map Verb (Maybe (ReaderT BL.ByteString m z), FileExts r) }
   deriving (Functor, Traversable)
 
-deriving instance             Monoid    (Verbs z a)
-deriving instance             Foldable  (Verbs z)
+deriving instance                  Monoid    (Verbs z m a)
+deriving instance                  Foldable  (Verbs z m)
 
 newtype VerbListenerT z r m a =
-  VerbListenerT { runVerbListenerT :: WriterT (Verbs z r) m a }
+  VerbListenerT { runVerbListenerT :: WriterT (Verbs z m r) m a }
     deriving (Functor)
 
 deriving instance Applicative m => Applicative (VerbListenerT z r m)
 deriving instance Monad m =>       Monad       (VerbListenerT z r m)
 deriving instance MonadIO m =>     MonadIO     (VerbListenerT z r m)
-deriving instance                  MonadTrans  (VerbListenerT z r)
+instance MonadTrans (VerbListenerT z r) where
+  lift ma = VerbListenerT $ lift ma
 
 
 get :: (Monad m) =>
@@ -56,25 +56,26 @@
 
 
 post :: (Monad m, MonadIO m) =>
-        (BL.ByteString -> z)
+        (BL.ByteString -> m z)
      -> FileExtListenerT Response m a
      -> VerbListenerT z Response m ()
 post handle flistener = do
   (fileexts :: FileExts Response) <- lift $ execWriterT $
                                      runFileExtListenerT flistener
-  let new = singleton Post (Just handle, fileexts)
+  let new = singleton Post (Just $ ReaderT handle, fileexts)
   VerbListenerT $ tell $ Verbs new
 
 
 put :: (Monad m, MonadIO m) =>
-       (BL.ByteString -> z)
+       (BL.ByteString -> m z)
     -> FileExtListenerT Response m a
     -> VerbListenerT z Response m ()
 put handle flistener = do
   (fileexts :: FileExts Response) <- lift $ execWriterT $
                                      runFileExtListenerT flistener
-  let new = singleton Put (Just handle, fileexts)
+  let new = singleton Put (Just $ ReaderT handle, fileexts)
   VerbListenerT $ tell $ Verbs new
+
 
 delete :: (Monad m) =>
           FileExtListenerT Response m a