diff --git a/next.config.mjs b/next.config.mjs
index 74b8a5c4a..d73b16681 100644
--- a/next.config.mjs
+++ b/next.config.mjs
@@ -36,6 +36,23 @@ const nextConfig = {
         permanent: true,
       },
       // redirects from old docs
+      ...[
+        '/docs/reference/go/secrets/secret-version',
+        '/docs/reference/go/secrets/secret-latest',
+        '/docs/reference/go/secrets/secret-version-access',
+        '/docs/reference/go/storage/bucket-file',
+        '/docs/reference/go/storage/bucket-files',
+        '/docs/reference/go/storage/bucket-file-read',
+        '/docs/reference/go/storage/bucket-file-write',
+        '/docs/reference/go/storage/bucket-file-delete',
+        '/docs/reference/go/storage/bucket-file-downloadurl',
+        '/docs/reference/go/storage/bucket-file-uploadurl',
+      ].map((source) => ({
+        source: source,
+        destination: `/docs/reference/go`,
+        basePath: false,
+        permanent: true,
+      })),
       ...[
         '/docs/testing',
         '/docs/guides/debugging',
diff --git a/src/nav.config.ts b/src/nav.config.ts
index 4e3997925..dc4005e52 100644
--- a/src/nav.config.ts
+++ b/src/nav.config.ts
@@ -2636,16 +2636,12 @@ const fullNav: FullNav = {
           href: '/reference/go/secrets/secret-put',
         },
         {
-          title: 'Secret.Version()',
-          href: '/reference/go/secrets/secret-version',
+          title: 'Secret.AccessVersion()',
+          href: '/reference/go/secrets/secret-access-version',
         },
         {
-          title: 'Secret.Latest()',
-          href: '/reference/go/secrets/secret-latest',
-        },
-        {
-          title: 'Secret.Version.Access()',
-          href: '/reference/go/secrets/secret-version-access',
+          title: 'Secret.Access()',
+          href: '/reference/go/secrets/secret-access',
         },
       ],
     },
@@ -2657,32 +2653,28 @@ const fullNav: FullNav = {
           href: '/reference/go/storage/bucket-on',
         },
         {
-          title: 'Bucket.File()',
-          href: '/reference/go/storage/bucket-file',
-        },
-        {
-          title: 'Bucket.Files()',
-          href: '/reference/go/storage/bucket-files',
+          title: 'Bucket.ListFiles()',
+          href: '/reference/go/storage/bucket-listfiles',
         },
         {
-          title: 'File.Read()',
-          href: '/reference/go/storage/bucket-file-read',
+          title: 'Bucket.Read()',
+          href: '/reference/go/storage/bucket-read',
         },
         {
-          title: 'File.Write()',
-          href: '/reference/go/storage/bucket-file-write',
+          title: 'Bucket.Write()',
+          href: '/reference/go/storage/bucket-write',
         },
         {
-          title: 'File.Delete()',
-          href: '/reference/go/storage/bucket-file-delete',
+          title: 'Bucket.Delete()',
+          href: '/reference/go/storage/bucket-delete',
         },
         {
-          title: 'File.DownloadUrl()',
-          href: '/reference/go/storage/bucket-file-downloadurl',
+          title: 'Bucket.DownloadUrl()',
+          href: '/reference/go/storage/bucket-downloadurl',
         },
         {
-          title: 'File.UploadUrl()',
-          href: '/reference/go/storage/bucket-file-uploadurl',
+          title: 'Bucket.UploadUrl()',
+          href: '/reference/go/storage/bucket-uploadurl',
         },
       ],
     },
diff --git a/src/pages/apis.mdx b/src/pages/apis.mdx
index b80dc3218..cd4c60bca 100644
--- a/src/pages/apis.mdx
+++ b/src/pages/apis.mdx
@@ -41,30 +41,17 @@ Nitric.run()
 package main
 
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	galaxyApi, err := nitric.NewApi("far-away-galaxy-api")
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	galaxyApi.Get("/moon", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		ctx.Response.Body = []byte("that's no moon, it's a space station.")
-
-		return next(ctx)
-	})
+  galaxyApi := nitric.NewApi("far-away-galaxy-api")
+  galaxyApi.Get("/moon", func(ctx *apis.Ctx) {
+    ctx.Response.Body = []byte("that's no moon, it's a space station.")
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-
-	fmt.Println("Service has started")
+  nitric.Run()
 }
 ```
 
@@ -126,39 +113,24 @@ async def create_planet(ctx):
 package main
 
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-	"github.com/your-org/your-repo/planets"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	galaxyApi, err := nitric.NewApi("far-away-galaxy-api")
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	galaxyApi.Get("/planets", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		ctx.Response.Headers = map[string][]string{"Content-Type": {"application/json"}}
-		ctx.Response.Body = []byte(GetPlanetList())
+  galaxyApi := nitric.NewApi("far-away-galaxy-api")
 
-		return next(ctx)
-	})
+  galaxyApi.Get("/planets", func(ctx *apis.Ctx) {
+    ctx.Response.Headers = map[string][]string{"Content-Type": {"application/json"}}
+    ctx.Response.Body = []byte(GetPlanetList())
+  })
 
-	galaxyApi.Post("/planets", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		CreatePlanet(ctx.Request.Data())
-		ctx.Response.Status = 201
+  galaxyApi.Post("/planets", func(ctx *apis.Ctx) {
+    CreatePlanet(ctx.Request.Data())
+    ctx.Response.Status = 201
+  })
 
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-
-	fmt.Println("Service has started")
+  nitric.Run()
 }
 
 ```
@@ -220,35 +192,23 @@ async def get_planet_route(ctx):
 package main
 
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-	"github.com/your-org/your-repo/planets"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	galaxyApi, err := nitric.NewApi("far-away-galaxy-api")
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+  galaxyApi := nitric.NewApi("far-away-galaxy-api")
 
-	// create a dynamic route and extract the parameter `name`
-	galaxyApi.Get("/planets/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		name := ctx.Request.PathParams()["name"]
+  // create a dynamic route and extract the parameter `name`
+  galaxyApi.Get("/planets/:name", func(ctx *apis.Ctx) {
+    name := ctx.Request.PathParams()["name"]
 
-		ctx.Response.Body = []byte(GetPlanet(name))
+    ctx.Response.Body = []byte(GetPlanet(name))
+  })
 
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-
-	fmt.Println("Service has started")
+  nitric.Run()
 }
+
 ```
 
 ```dart
@@ -290,11 +250,9 @@ async def find_alderaan(ctx):
 
 ```go
 // return a redirect response using status 301
-galaxyApi.Get("/planets/alderaan", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+galaxyApi.Get("/planets/alderaan", func(ctx *apis.Ctx) {
   ctx.Response.Status = 301
   ctx.Response.Location = "https://example.org/debris/alderaan"
-
-  return next(ctx)
 })
 ```
 
@@ -379,25 +337,23 @@ Nitric.run()
 package main
 
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	defaultSecurityRule := nitric.OidcRule("default", "https://dev-abc123.us.auth0.com", []string{"https://test-security-definition/"})
-
-	secureApi, err := nitric.NewApi(
-		"main",
-		nitric.WithSecurity(defaultSecurityRule([]string{})),
-	)
-	if err != nil {
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  defaultSecurityRule := apis.OidcRule(
+    "default",
+    "https://dev-abc123.us.auth0.com/.well-known/openid-configuration",
+    []string{"https://test-security-definition"},
+  )
+
+  secureApi := nitric.NewApi(
+    "main",
+    apis.WithSecurity(defaultSecurityRule([]string{})),
+  )
+
+  nitric.Run()
 }
 ```
 
@@ -471,26 +427,25 @@ Nitric.run()
 package main
 
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	defaultSecurityRule := nitric.OidcRule("default", "https://dev-abc123.us.auth0.com", []string{"https://test-security-definition/"})
-
-	secureApi, err := nitric.NewApi(
-		"main",
-		nitric.WithSecurity(defaultSecurityRule([]string{"user.read"})),
-	)
-	if err != nil {
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  defaultSecurityRule := apis.OidcRule(
+    "default",
+    "https://dev-abc123.us.auth0.com/.well-known/openid-configuration",
+    []string{"https://test-security-definition/"},
+  )
+
+  secureApi := nitric.NewApi(
+    "main",
+    apis.WithSecurity(defaultSecurityRule([]string{"user.read"})),
+  )
+
+  nitric.Run()
 }
+
 ```
 
 ```dart
@@ -552,16 +507,14 @@ async def get_planet(ctx):
 
 ```go
 // override top level security to remove security from this route
-secureApi.Get("/planets/unsecured-planet", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+secureApi.Get("/planets/unsecured-planet", func(ctx *apis.Ctx) {
 	// Handle request
-	return next(ctx)
-}, nitric.WithNoMethodSecurity())
+}, apis.WithNoMethodSecurity())
 
 // override top level security to require user.write scope to access
-secureApi.Get("/planets/unsecured-planet", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+secureApi.Get("/planets/unsecured-planet", func(ctx *apis.Ctx) {
 	// Handle request
-	return next(ctx)
-}, nitric.WithSecurity(customRule([]string{"users:write"})))
+}, apis.WithSecurity(customRule([]string{"users:write"})))
 ```
 
 ```dart
@@ -580,9 +533,9 @@ galaxyApi.post("/planets/unsecured-planet", (ctx) async {
 
 ## Defining Middleware
 
-Behavior that's common to several APIs or routes can be applied using middleware services. Multiple middleware can also be composed to create a cascading set of steps to perform on incoming requests or outgoing responses.
+Behavior that's common to several APIs or routes can be applied using middleware. Multiple middleware can also be composed to create a cascading set of steps to perform on incoming requests or outgoing responses.
 
-Middleware services look nearly identical to handlers except for an additional parameter called `next`, which is the next middleware or handler to be called in the chain. By providing each middleware the next middleware in the chain it allows them to intercept requests, response and errors to perform operations like logging, decoration, exception handling and many other common tasks.
+In most of Nitric's supported languages middleware functions look nearly identical to handlers except for an additional parameter called `next`, which is the next middleware or handler to be called in the chain. By providing each middleware the next middleware in the chain it allows them to intercept requests, response and errors to perform operations like logging, decoration, exception handling and many other common tasks.
 
 <CodeGroup>
 
@@ -600,22 +553,25 @@ async function validate(ctx, next) {
 ```python
 async def validate(ctx, nxt: HttpMiddleware):
   if ctx.req.headers['content-type'] is None:
-    ctx.res.status = 400;
+    ctx.res.status = 400
     ctx.res.body = "header Content-Type is required"
     return ctx
   return await nxt(ctx)
 ```
 
 ```go
-func validate(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-	if ctx.Request.Headers()["content-type"] != nil {
-		ctx.Response.Status = 400
-		ctx.Response.Body = []byte("header Content-Type is required")
+// Using the Go SDK we recommend using higher-order functions to define middleware
+func validate(next apis.Handler) apis.Handler {
+  return func (ctx *apis.Ctx) error {
+    if ctx.Request.Headers()["content-type"] != nil {
+      ctx.Response.Status = 400
+      ctx.Response.Body = []byte("header Content-Type is required")
 
-		return ctx, nil
-	}
+      return nil
+    }
 
-	return next(ctx)
+    return next(ctx)
+  }
 }
 ```
 
@@ -652,35 +608,29 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
-func validate(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-	if ctx.Request.Headers()["content-type"] != nil {
-		ctx.Response.Status = 400
-		ctx.Response.Body = []byte("header Content-Type is required")
+func validate(next apis.Handler) apis.Handler {
+  return func(ctx *apis.Ctx) error {
+    if ctx.Request.Headers()["content-type"] != nil {
+      ctx.Response.Status = 400
+      ctx.Response.Body = []byte("header Content-Type is required")
 
-		return ctx, nil
-	}
+      return nil
+    }
 
-	return next(ctx)
+    return next(ctx)
+  }
 }
 
 func main() {
-	customersApi, err := nitric.NewApi(
-		"customers",
-		nitric.WithMiddleware(validate))
-
-	if err != nil {
-		return
-	}
+  customersApi := nitric.NewApi(
+    "customers",
+    apis.WithMiddleware(validate))
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -717,38 +667,32 @@ Route level middleware currently not supported in python
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
-func validate(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-	if ctx.Request.Headers()["content-type"] != nil {
-		ctx.Response.Status = 400
-		ctx.Response.Body = []byte("header Content-Type is required")
+func validate(next apis.Handler) apis.Handler {
+  return func(ctx *apis.Ctx) error {
+    if ctx.Request.Headers()["content-type"] != nil {
+      ctx.Response.Status = 400
+      ctx.Response.Body = []byte("header Content-Type is required")
 
-		return ctx, nil
-	}
+      return nil
+    }
 
-	return next(ctx)
+    return next(ctx)
+  }
 }
 
 func main() {
-	customersApi, err := nitric.NewApi(
-		"customers")
-
-	if err != nil {
-		return
-	}
+  customersApi := nitric.NewApi("customers")
 
-	customersApi.Get("/customers", handler.ComposeHttpMiddleware(validate, func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		return next(ctx)
-	}))
+  customersApi.Get("/customers", validate(func(ctx *apis.Ctx) error {
+    // handle request
+    return nil
+  }))
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -912,30 +856,19 @@ Nitric.run()
 ```
 
 ```go {{ tag: 'services/one/main.go' }}
-package main
-
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	accountsApi, err := nitric.NewApi("accounts")
+  accountsApi := nitric.NewApi("accounts")
 
-	if err != nil {
-		return
-	}
+  accountsApi.Get("/users/:id", func(ctx *apis.Ctx) {
+    // your logic here
+  })
 
-	accountsApi.Get("/users/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// your logic here
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -978,30 +911,19 @@ Nitric.run()
 ```
 
 ```go {{ tag: 'services/two/main.go' }}
-package main
-
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	accountsApi, err := nitric.NewApi("accounts")
-
-	if err != nil {
-		return
-	}
+  accountsApi := nitric.NewApi("accounts")
 
-	accountsApi.Get("/orgs/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// your logic here
-		return next(ctx)
-	})
+  accountsApi.Get("/orgs/:id", func(ctx *apis.Ctx) {
+    // your logic here
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -1043,19 +965,16 @@ accounts_api = api('accounts')
 ```
 
 ```go {{ tag: 'resources/main.go' }}
-package resources
-
-import "github.com/nitrictech/go-sdk/nitric"
+import (
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
+)
 
-var AccountsApi nitric.Api
+var AccountsApi apis.Api
 
 func init() {
-	accountsApi, err := nitric.NewApi("accounts")
-	if err != nil {
-		panic(err)
-	}
-
-	AccountsApi = accountsApi
+  accountsApi := nitric.NewApi("accounts")
+  AccountsApi = accountsApi
 }
 ```
 
@@ -1094,22 +1013,18 @@ Nitric.run()
 package main
 
 import (
-	"fmt"
+  "your/resources"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-    "github.com/your-org/your-repo/resources"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	Resources.AccountsApi.Get("/users/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// your logic here
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  resources.AccountsApi.Get("/users/:id", func(ctx *apis.Ctx) {
+    // your logic here
+  })
+
+  nitric.Run()
 }
 ```
 
@@ -1150,22 +1065,18 @@ Nitric.run()
 package main
 
 import (
-	"fmt"
+  "your/resources"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-    "github.com/your-org/your-repo/resources"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	Resources.AccountsApi.Get("/orgs/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// your logic here
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  resources.AccountsApi.Get("/orgs/:id", func(ctx *apis.Ctx) {
+    // your logic here
+  })
+
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/concepts/comparison/encore.mdx b/src/pages/concepts/comparison/encore.mdx
index 6691606d5..28bd7d9ed 100644
--- a/src/pages/concepts/comparison/encore.mdx
+++ b/src/pages/concepts/comparison/encore.mdx
@@ -22,7 +22,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/faas"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -33,12 +33,10 @@ func main() {
 		return
 	}
 
-	mainApi.Get("/hello/:name", func(ctx *faas.HttpContext, next faas.HttpHandler) (*faas.HttpContext, error) {
+	mainApi.Get("/hello/:name", func(ctx *apis.Ctx) {
 		params := ctx.Request.PathParams()
 
 		ctx.Response.Body = []byte("Hello " + params["name"])
-
-		return next(ctx)
 	})
 
 	if err := nitric.Run(); err != nil {
@@ -74,7 +72,7 @@ The Nitric example shows an API where HTTP request handling is achieved using `f
 |                      | Nitric                                                                                       | Encore                     |
 | -------------------- | -------------------------------------------------------------------------------------------- | -------------------------- |
 | Language             | Your choice                                                                                  | Go                         |
-| Lines of code        | 27                                                                                           | 15                         |
+| Lines of code        | 26                                                                                           | 15                         |
 | Cloud Infrastructure | Inferred                                                                                     | Inferred                   |
 | Extensibility        | [Custom providers](/reference/providers/custom/building-custom-provider) can be created      | No                         |
 | Local simulation     | Built-in local simulator                                                                     | Built-in local simulator   |
diff --git a/src/pages/getting-started/quickstart.mdx b/src/pages/getting-started/quickstart.mdx
index 55fc203cd..dcaf48df1 100644
--- a/src/pages/getting-started/quickstart.mdx
+++ b/src/pages/getting-started/quickstart.mdx
@@ -272,7 +272,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -283,25 +283,19 @@ func main() {
 		return
 	}
 
-	api.Get("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	api.Get("/hello/:name", func(ctx *apis.Ctx) {
 		name := ctx.Request.PathParams()["name"]
 		ctx.Response.Body = []byte(fmt.Sprintf("Hello %s", name))
-
-		return next(ctx)
 	})
 
-	api.Get("/goodbye/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	api.Get("/goodbye/:name", func(ctx *apis.Ctx) {
 		name := ctx.Request.PathParams()["name"]
 		ctx.Response.Body = []byte(fmt.Sprintf("Goodbye %s", name))
-
-		return next(ctx)
 	})
 
 	if err := nitric.Run(); err != nil {
 		fmt.Println(err)
 	}
-
-	fmt.Println("Service has started")
 }
 ```
 
diff --git a/src/pages/getting-started/resources-overview.mdx b/src/pages/getting-started/resources-overview.mdx
index 564b16e90..f4733fec5 100644
--- a/src/pages/getting-started/resources-overview.mdx
+++ b/src/pages/getting-started/resources-overview.mdx
@@ -56,7 +56,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -70,11 +70,9 @@ func main() {
 	// ✅ This declaration will work
 	bucket, err := nitric.NewBucket("files").Allow(nitric.BucketRead)
 
-	api.Get("/files/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	api.Get("/files/:name", func(ctx *apis.Ctx) {
 		// ❌ This declaration will not work, as this is only called at runtime.
 		badBucket, err := nitric.NewBucket("wont-work").Allow(nitric.BucketRead)
-
-		return next(ctx)
 	})
 
 	if err := nitric.Run(); err != nil {
@@ -155,7 +153,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -170,20 +168,16 @@ func main() {
 	bucket, err := nitric.NewBucket("files").Allow(nitric.BucketRead)
 
 	// ❌ This access will not work
-	fileContents, _ := bucket.File("example.txt").Read()
+	fileContents, _ := bucket.Read(context.TODO(), "example.txt")
 
-	api.Get("/files/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	api.Get("/files/:name", func(ctx *apis.Ctx) {
 		// ✅ This access will work
-		fileContents, _ := bucket.File("example.txt").Read()
-
-		return next(ctx)
+		fileContents, _ := bucket.Read(context.TODO(), "example.txt")
 	})
 
 	if err := nitric.Run(); err != nil {
 		fmt.Println(err)
 	}
-
-	fmt.Println("Service has started")
 }
 ```
 
@@ -329,7 +323,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
 	"github.com/nitrictech/go-sdk/nitric"
 	"github.com/nitrictech/your-org/your-repo/resources"
 )
@@ -340,19 +333,15 @@ func main() {
 		panic(err)
 	}
 
-	resources.PublicApi.Post("/update", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	resources.PublicApi.Post("/update", func() {
 		publisher.Publish(context.TODO(), map[string]interface{}{
 			"test": "message",
 		})
-
-		return next(ctx)
 	})
 
 	if err := nitric.Run(); err != nil {
 		fmt.Println(err)
 	}
-
-	fmt.Println("Api service has started")
 }
 
 
@@ -362,16 +351,13 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
 	"github.com/nitrictech/go-sdk/nitric"
 	"github.com/nitrictech/your-org/your-repo/resources"
 )
 
 func main() {
-	resources.UpdateTopic.Subscribe(func(mc *handler.MessageContext, mh handler.MessageHandler) (*handler.MessageContext, error) {
+	resources.UpdateTopic.Subscribe(func() {
 		println("got the message")
-
-		return mc, nil
 	})
 
 	if err := nitric.Run(); err != nil {
@@ -516,22 +502,19 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 	"github.com/your-org/your-repo/resources"
 )
 
 func main() {
-	resources.PublicApi.Get("/bucket-one/file/:name", func(hc *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	resources.PublicApi.Get("/bucket-one/file/:name", func(ctx *apis.Ctx) {
 		// do something with the file
-		return next(hc)
 	})
 
 	if err := nitric.Run(); err != nil {
 		fmt.Println(err)
 	}
-
-	fmt.Println("Service has started")
 }
 
 // services/service-two/main.go
@@ -540,22 +523,19 @@ package main
 import (
 	"fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 	"github.com/nitrictech/go-sdk/nitric"
 	"github.com/your-org/your-repo/resources"
 )
 
 func main() {
-	resources.PublicApi.Get("/bucket-two/file/:name", func(hc *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+	resources.PublicApi.Get("/bucket-two/file/:name", func(hc *apis.Ctx) {
 		// do something with the file
-		return next(hc)
 	})
 
 	if err := nitric.Run(); err != nil {
 		fmt.Println(err)
 	}
-
-	fmt.Println("Service has started")
 }
 ```
 
diff --git a/src/pages/guides/go/serverless-rest-api-example.mdx b/src/pages/guides/go/serverless-rest-api-example.mdx
index 88a0e0385..0294b1368 100644
--- a/src/pages/guides/go/serverless-rest-api-example.mdx
+++ b/src/pages/guides/go/serverless-rest-api-example.mdx
@@ -82,32 +82,17 @@ If everything is working as expected you can now delete all files/folders in the
 Let's begin by setting up the Profiles API. First, create a new folder called `profiles` within the services directory. Inside this folder, add a file named `main.go`, and include the following code:
 
 ```go
-package main
-
 import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/google/uuid"
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-  profilesApi, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  profilesApi := nitric.NewApi("public")
 
-  profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet)
-  if err != nil {
-    return
-  }
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -127,30 +112,29 @@ From here, let's add some features to that function that allow us to work with p
 ### Create profiles with POST
 
 ```go
-profilesApi.Post("/profiles", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Post("/profiles", func(ctx *apis.Ctx) error {
   id := uuid.New().String()
 
   var profileRequest map[string]interface{}
   err := json.Unmarshal(ctx.Request.Data(), &profileRequest)
   if err != nil {
-    return ctx, err
+    return err
   }
 
   err = profiles.Set(context.Background(), id, profileRequest)
   if err != nil {
-    return ctx, err
+    return err
   }
 
   ctx.Response.Body = []byte(id)
-
-  return ctx, nil
+  return nil
 })
 ```
 
 ### Retrieve a profile with GET
 
 ```go
-profilesApi.Get("/profiles/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Get("/profiles/:id", func(ctx *apis.Ctx) {
   id := ctx.Request.PathParams()["id"]
 
   profile, err := profiles.Get(context.Background(), id)
@@ -158,22 +142,20 @@ profilesApi.Get("/profiles/:id", func(ctx *handler.HttpContext, next handler.Htt
     ctx.Response.Status = 404
     ctx.Response.Body = []byte(fmt.Sprintf("profile with id '%s' not found", id))
 
-    return ctx, nil
+    return
   }
 
   ctx.Response.Body, err = json.Marshal(profile)
-
-  return ctx, err
 })
 ```
 
 ### List all profiles with GET
 
 ```go
-profilesApi.Get("/profiles", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Get("/profiles", func(ctx *apis.Ctx) error {
   keys, err := profiles.Keys(context.TODO())
   if err != nil {
-    return ctx, err
+    return err
   }
 
   var profileContent []map[string]interface{}
@@ -188,14 +170,14 @@ profilesApi.Get("/profiles", func(ctx *handler.HttpContext, next handler.HttpHan
 
   ctx.Response.Body, err = json.Marshal(profileContent)
 
-  return ctx, err
+  return err
 })
 ```
 
 ### Remove a profile with DELETE
 
 ```go
-profilesApi.Delete("/profiles/:id", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Delete("/profiles/:id", func(ctx *apis.Ctx) {
   id := ctx.Request.PathParams()["id"]
 
   err := profiles.Delete(context.Background(), id)
@@ -203,10 +185,8 @@ profilesApi.Delete("/profiles/:id", func(ctx *handler.HttpContext, next handler.
     ctx.Response.Status = 404
     ctx.Response.Body = []byte(fmt.Sprintf("profile with id '%s' not found", id))
 
-    return ctx, nil
+    return
   }
-
-  return ctx, nil
 })
 ```
 
@@ -303,65 +283,61 @@ If you want to go a bit deeper and create some other resources with Nitric, why
 Define a bucket named `profileImages` with read/write permissions
 
 ```go
-profileImages, err := nitric.NewBucket("profileImages").Allow(nitric.BucketRead, nitric.BucketWrite)
-if err != nil {
-  fmt.Println(err)
-  return
-}
+profileImages := nitric.NewBucket("profileImages").Allow(storage.BucketRead, storage.BucketWrite)
 ```
 
 ### Get a URL to upload a profile image
 
 ```go
-profilesApi.Get("/profiles/:id/image/upload", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Get("/profiles/:id/image/upload", func(ctx *apis.Ctx) error {
   id := ctx.Request.PathParams()["id"]
   photoId := fmt.Sprintf("images/%s/photo.png", id)
 
-  photoUrl, err := profileImages.File(photoId).UploadUrl(context.TODO(), 600)
+  photoUrl, err := profileImages.UploadUrl(context.TODO(), photoId, storage.WithPresignUrlExpiry(600))
   if err != nil {
-    return ctx, err
+    return err
   }
 
   ctx.Response.Body = []byte(photoUrl)
 
-  return ctx, nil
+  return nil
 })
 ```
 
 ### Get a URL to download a profile image
 
 ```go
-profilesApi.Get("/profiles/:id/image/download", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+profilesApi.Get("/profiles/:id/image/download", func(ctx *apis.Ctx) error {
   id := ctx.Request.PathParams()["id"]
   photoId := fmt.Sprintf("images/%s/photo.png", id)
 
-  photoUrl, err := profileImages.File(photoId).DownloadUrl(context.TODO(), 600)
+  photoUrl, err := profileImages.DownloadUrl(context.TODO(), photoId, storage.WithPresignUrlExpiry(600))
   if err != nil {
-    return ctx, err
+    return err
   }
 
   ctx.Response.Body = []byte(photoUrl)
 
-  return ctx, nil
+  return nil
 })
 ```
 
 You can also directly redirect to the photo URL.
 
 ```go
-profilesApi.Get("/profiles/:id/image/view", func(ctx *faas.HttpContext, next faas.HttpHandler) (*faas.HttpContext, error) {
+profilesApi.Get("/profiles/:id/image/view", func(ctx *apis.Ctx) error {
   id := ctx.Request.PathParams()["id"]
   photoId := fmt.Sprintf("images/%s/photo.png", id)
 
-  photoUrl, err := profileImages.File(photoId).DownloadUrl(ctx.Request.Context(), 600)
+  photoUrl, err := profileImages.DownloadUrl(context.TODO(), photoId, storage.WithPresignUrlExpiry(600))
   if err != nil {
-    return ctx, err
+    return err
   }
 
   ctx.Response.Status = 303
   ctx.Response.Headers["Location"] = []string{photoUrl}
 
-  return ctx, nil
+  return nil
 })
 ```
 
diff --git a/src/pages/keyvalue.mdx b/src/pages/keyvalue.mdx
index b12d2b19a..773400bde 100644
--- a/src/pages/keyvalue.mdx
+++ b/src/pages/keyvalue.mdx
@@ -54,21 +54,14 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	countries, err := nitric.NewKv("Countries").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  countries := nitric.NewKv("Countries").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  nitric.Run()
 }
 ```
 
@@ -121,21 +114,21 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
-countries, _ := nitric.NewKv("Countries").Allow(nitric.KvStoreSet)
+func main() {
+  countries := nitric.NewKv("Countries").Allow(keyvalue.KvStoreSet)
 
-_ = countries.Set(context.TODO(), "USA", map[string]interface{}{
-	"name":      "United States of America",
-	"population": 329500000,
-})
+  _ = countries.Set(context.TODO(), "USA", map[string]interface{}{
+    "name":       "United States of America",
+    "population": 329500000,
+  })
 
-if err := nitric.Run(); err != nil {
-	fmt.Println(err)
+  nitric.Run()
 }
 ```
 
@@ -215,18 +208,18 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
-countries, _ := nitric.NewKv("Countries").Allow(nitric.KvStoreGet)
+func main() {
+  countries := nitric.NewKv("Countries").Allow(keyvalue.KvStoreGet)
 
-country, _ := countries.Get(context.TODO(), "USA")
+  country, _ := countries.Get(context.TODO(), "USA")
 
-if err := nitric.Run(); err != nil {
-	fmt.Println(err)
+  nitric.Run()
 }
 ```
 
@@ -281,23 +274,23 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
-countries, _ := nitric.NewKv("Countries").Allow(nitric.KvStoreSet, nitric.KvStoreDelete)
+func main() {
+  countries := nitric.NewKv("Countries").Allow(keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
 
-_ = countries.Set(context.TODO(), "USA", map[string]interface{}{
-	"name":       "United States of America",
-	"population": 329500000,
-})
+  _ = countries.Set(context.TODO(), "USA", map[string]interface{}{
+    "name":       "United States of America",
+    "population": 329500000,
+  })
 
-_ = countries.Delete(context.TODO(), "USA")
+  _ = countries.Delete(context.TODO(), "USA")
 
-if err := nitric.Run(); err != nil {
-	fmt.Println(err)
+  nitric.Run()
 }
 ```
 
@@ -351,28 +344,30 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
-countries, _ := nitric.NewKv("Countries").Allow(nitric.KvStoreGet)
+func main() {
 
-keys, _ := profiles.Keys(context.TODO())
+  countries := nitric.NewKv("Countries").Allow(keyvalue.KvStoreGet)
 
-for {
-	key, err := keys.Recv()
-	if err != nil {
-		// check if the stream has ended
-		break
-	}
+  keys, _ := countries.Keys(context.TODO())
 
-	fmt.Println(key)
-}
+  for {
+    key, err := keys.Recv()
+    if err != nil {
+      // check if the stream has ended
+      break
+    }
+
+    fmt.Println(key)
+  }
 
-if err := nitric.Run(); err != nil {
-	fmt.Println(err)
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/messaging.mdx b/src/pages/messaging.mdx
index c781732d1..c81d4cbff 100644
--- a/src/pages/messaging.mdx
+++ b/src/pages/messaging.mdx
@@ -42,17 +42,14 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-	userCreatedTopic, _ := nitric.NewTopic("user-created").Allow(nitric.TopicPublish)
+  userCreatedTopic := nitric.NewTopic("user-created").Allow(topics.TopicPublish)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -99,22 +96,20 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-	userCreatedTopic, _ := nitric.NewTopic("user-created").Allow(nitric.TopicPublish)
+  userCreatedTopic := nitric.NewTopic("user-created").Allow(topics.TopicPublish)
 
-	_ = userCreatedTopic.Publish(context.TODO(), map[string]interface{}{
-		"email": "new.user@example.com",
-	})
+  _ = userCreatedTopic.Publish(context.TODO(), map[string]interface{}{
+    "email": "new.user@example.com",
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -172,27 +167,24 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-	"github.com/your-org/your-project/common"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-	userCreatedTopic := nitric.NewTopic("user-created")
+  userCreatedTopic := nitric.NewTopic("user-created")
 
-	userCreatedTopic.Subscribe(func(ctx *handler.MessageContext, next handler.MessageHandler) (*handler.MessageContext, error) {
-		email := ctx.Request.Message()["email"].(string)
+  userCreatedTopic.Subscribe(func(ctx *topics.Ctx) {
+    email := ctx.Request.Message()["email"].(string)
 
-		sendWelcomeEmail(email)
+    sendWelcomeEmail(email)
+  })
 
-		return ctx, nil
-	})
+  nitric.Run()
+}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+func sendWelcomeEmail(email string) {
+  // TODO: Implement email sending
 }
 ```
 
@@ -272,30 +264,24 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-	"github.com/your-org/your-project/common"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
+  "github.com/your-org/your-project/common"
 )
 
 func main() {
-	userCreatedTopic := nitric.NewTopic("updates")
-
-	userCreatedTopic.Subscribe(func(ctx *handler.MessageContext, next handler.MessageHandler) (*handler.MessageContext, error) {
-		if common.isDuplicate(ctx.Request) {
-			return ctx, nil
-		}
+  userCreatedTopic := nitric.NewTopic("updates")
 
-		// not a duplicate, process the event
-  		// ...
+  userCreatedTopic.Subscribe(func(ctx *topics.Ctx) {
+    if common.isDuplicate(ctx.Request) {
+      return
+    }
 
-		return ctx, nil
-	})
+    // not a duplicate, process the event
+    // ...
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -364,17 +350,14 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	transactionQueue, _ := nitric.NewQueue("transactions").Allow(nitric.QueueEnqueue, nitric.QueueDequeue)
+  transactionQueue := nitric.NewQueue("transactions").Allow(queues.QueueEnqueue, queues.QueueDequeue)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -421,24 +404,22 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	transactionQueue, _ := nitric.NewQueue("transactions").Allow(nitric.QueueEnqueue)
+  transactionQueue := nitric.NewQueue("transactions").Allow(queues.QueueEnqueue)
 
-	messages := []map[string]interface{}{
-		{"message": "hello world"},
-	}
+  messages := []map[string]interface{}{
+    {"message": "hello world"},
+  }
 
-	transactionQueue.Enqueue(context.TODO(), messages)
+  transactionQueue.Enqueue(context.TODO(), messages)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -494,25 +475,23 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	transactionQueue, _ := nitric.NewQueue("transactions").Allow(nitric.QueueEnqueue)
+  transactionQueue := nitric.NewQueue("transactions").Allow(queues.QueueEnqueue)
 
-	messages := []map[string]interface{}{
-		{"message": "batch task 1"},
-		{"message": "batch task 2"},
-	}
+  messages := []map[string]interface{}{
+    {"message": "batch task 1"},
+    {"message": "batch task 2"},
+  }
 
-	transactionQueue.Enqueue(context.TODO(), messages)
+  transactionQueue.Enqueue(context.TODO(), messages)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -581,28 +560,27 @@ for task in tasks:
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	transactionQueue, _ := nitric.NewQueue("transactions").Allow(nitric.QueueDequeue)
+  transactionQueue := nitric.NewQueue("transactions").Allow(queues.QueueDequeue)
 
-	messages, _ := transactionQueue.Dequeue(context.TODO(), 10)
+  messages, _ := transactionQueue.Dequeue(context.TODO(), 10)
 
-	for _, message := range messages {
-		// process your message's data
-		fmt.Println(message.Message())
+  for _, message := range messages {
+    // process your message's data
+    fmt.Println(message.Message())
 
-		// acknowledge when the message is complete
-		message.Complete(context.TODO())
-	}
+    // acknowledge when the message is complete
+    message.Complete(context.TODO())
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/api/api-delete.mdx b/src/pages/reference/go/api/api-delete.mdx
index c38b07bfd..ffb991f03 100644
--- a/src/pages/reference/go/api/api-delete.mdx
+++ b/src/pages/reference/go/api/api-delete.mdx
@@ -14,7 +14,7 @@ Register an API route and set a specific HTTP DELETE handler on that route.
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
+  "github.com/nitrictech/go-sdk/nitric/apis"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -24,29 +24,25 @@ func main() {
     return
   }
 
-  api.Delete("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Delete("/hello", func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="match" required type="string">
+  <Property name="path" required type="string">
     The path matcher to use for the route. Matchers accept path parameters in
     the form of a colon prefixed string. The string provided will be used as
     that path parameter's name when calling middleware and handlers. See [create
     a route with path params](#create-a-route-with-path-params).
   </Property>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle requests to the given path and method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -57,7 +53,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -77,119 +73,39 @@ func main() {
 ### Register a handler for DELETE requests
 
 ```go
-api.Delete("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Delete("/hello", func(ctx *apis.Ctx) {
   ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
 })
 ```
 
 ### Create a route with path params
 
 ```go
-api.Delete("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Delete("/hello/:name", func(ctx *apis.Ctx) {
   name := ctx.Request.PathParams()["name"]
   ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
 })
 ```
 
-### Create a route with no method security
-
-```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-	// Override the APIs security requirements with `WithNoMethodSecurity()`
-	secureApi.Delete("/public", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// Handle request
-		return next(ctx)
-	}, nitric.WithNoMethodSecurity())
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.Delete("/hello/:name", handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
 ### Access the request body
 
 The DELETE request body is accessible using `ctx.Request.Data()`.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Delete("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Delete("/hello", func(ctx *apis.Ctx) {
     data := ctx.Request.Data()
 
     ctx.Response.Body = data
-
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/api/api-get.mdx b/src/pages/reference/go/api/api-get.mdx
index 32b4caeca..86c0f7bda 100644
--- a/src/pages/reference/go/api/api-get.mdx
+++ b/src/pages/reference/go/api/api-get.mdx
@@ -12,41 +12,32 @@ Register an API route and set a specific HTTP GET handler on that route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
+  "github.com/nitrictech/go-sdk/nitric/apis"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Get("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Get("/hello", func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="match" required type="string">
+  <Property name="path" required type="string">
     The path matcher to use for the route. Matchers accept path parameters in
     the form of a colon prefixed string. The string provided will be used as
     that path parameter's name when calling middleware and handlers. See [create
     a route with path params](#create-a-route-with-path-params).
   </Property>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle requests to the given path and method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -57,7 +48,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -77,87 +68,16 @@ func main() {
 ### Register a handler for GET requests
 
 ```go
-api.Get("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Get("/hello", func(ctx *apis.Ctx) {
   ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
 })
 ```
 
 ### Create a route with path params
 
 ```go
-api.Get("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Get("/hello/:name", func(ctx *apis.Ctx) {
   name := ctx.Request.PathParams()["name"]
   ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
 })
 ```
-
-### Create a route with no method security
-
-```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-	// Override the APIs security requirements with `WithNoMethodSecurity()`
-	secureApi.Get("/public", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// Handle request
-		return next(ctx)
-	}, nitric.WithNoMethodSecurity())
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.Get("/hello/:name", handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-patch.mdx b/src/pages/reference/go/api/api-patch.mdx
index 63857e639..65d203042 100644
--- a/src/pages/reference/go/api/api-patch.mdx
+++ b/src/pages/reference/go/api/api-patch.mdx
@@ -12,41 +12,32 @@ Register an API route and set a specific HTTP PATCH handler on that route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Patch("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Patch("/hello", func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="match" required type="string">
+  <Property name="path" required type="string">
     The path matcher to use for the route. Matchers accept path parameters in
     the form of a colon prefixed string. The string provided will be used as
     that path parameter's name when calling middleware and handlers. See [create
     a route with path params](#create-a-route-with-path-params).
   </Property>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle requests to the given path and method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -57,7 +48,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -77,119 +68,39 @@ func main() {
 ### Register a handler for PATCH requests
 
 ```go
-api.Patch("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Patch("/hello", func(ctx *apis.Ctx) {
   ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
 })
 ```
 
 ### Create a route with path params
 
 ```go
-api.Patch("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Patch("/hello/:name", func(ctx *apis.Ctx) {
   name := ctx.Request.PathParams()["name"]
   ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
 })
 ```
 
-### Create a route with no method security
-
-```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-	// Override the APIs security requirements with `WithNoMethodSecurity()`
-	secureApi.Patch("/public", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// Handle request
-		return next(ctx)
-	}, nitric.WithNoMethodSecurity())
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.Patch("/hello/:name", handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
 ### Access the request body
 
 The PATCH request body is accessible using `ctx.Request.Data()`.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+	api := nitric.NewApi("public")
 
-  api.Patch("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
+	api.Patch("/hello", func(ctx *apis.Ctx) {
+		data := ctx.Request.Data()
 
-    ctx.Response.Body = data
-
-    return next(ctx)
-  })
+		ctx.Response.Body = data
+	})
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/api/api-post.mdx b/src/pages/reference/go/api/api-post.mdx
index 4c2f67fe0..3efd7df93 100644
--- a/src/pages/reference/go/api/api-post.mdx
+++ b/src/pages/reference/go/api/api-post.mdx
@@ -12,41 +12,32 @@ Register an API route and set a specific HTTP POST handler on that route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Post("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Post("/hello", func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="match" required type="string">
+  <Property name="path" required type="string">
     The path matcher to use for the route. Matchers accept path parameters in
     the form of a colon prefixed string. The string provided will be used as
     that path parameter's name when calling middleware and handlers. See [create
     a route with path params](#create-a-route-with-path-params).
   </Property>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle requests to the given path and method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -57,7 +48,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -77,119 +68,39 @@ func main() {
 ### Register a handler for POST requests
 
 ```go
-api.Post("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Post("/hello", func(ctx *apis.Ctx) {
   ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
 })
 ```
 
 ### Create a route with path params
 
 ```go
-api.Post("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Post("/hello/:name", func(ctx *apis.Ctx) {
   name := ctx.Request.PathParams()["name"]
   ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
 })
 ```
 
-### Create a route with no method security
-
-```go
- import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-	// Override the APIs security requirements with `WithNoMethodSecurity()`
-	secureApi.Post("/public", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// Handle request
-		return next(ctx)
-	}, nitric.WithNoMethodSecurity())
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.Post("/hello/:name", handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
 ### Access the request body
 
 The POST request body is accessible using `ctx.Request.Data()`.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Post("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Post("/hello", func(ctx *apis.Ctx) {
     data := ctx.Request.Data()
 
     ctx.Response.Body = data
-
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/api/api-put.mdx b/src/pages/reference/go/api/api-put.mdx
index 6ad718713..cce6b45f5 100644
--- a/src/pages/reference/go/api/api-put.mdx
+++ b/src/pages/reference/go/api/api-put.mdx
@@ -12,41 +12,32 @@ Register an API route and set a specific HTTP PUT handler on that route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  api.Put("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
-  })
+	api := nitric.NewApi("public")
+
+	api.Put("/hello", func(ctx *apis.Ctx) {
+		ctx.Response.Body = []byte("Hello World")
+	})
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="match" required type="string">
+  <Property name="path" required type="string">
     The path matcher to use for the route. Matchers accept path parameters in
     the form of a colon prefixed string. The string provided will be used as
     that path parameter's name when calling middleware and handlers. See [create
     a route with path params](#create-a-route-with-path-params).
   </Property>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle requests to the given path and method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -57,7 +48,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -77,119 +68,39 @@ func main() {
 ### Register a handler for PUT requests
 
 ```go
-api.Put("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Put("/hello", func(ctx *apis.Ctx) {
   ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
 })
 ```
 
 ### Create a route with path params
 
 ```go
-api.Put("/hello/:name", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+api.Put("/hello/:name", func(ctx *apis.Ctx) {
   name := ctx.Request.PathParams()["name"]
   ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
 })
 ```
 
-### Create a route with no method security
-
-```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-	// Override the APIs security requirements with `WithNoMethodSecurity()`
-	secureApi.Put("/public", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-		// Handle request
-		return next(ctx)
-	}, nitric.WithNoMethodSecurity())
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.Put("/hello/:name", handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
 ### Access the request body
 
 The PUT request body is accessible using `ctx.Request.Data()`.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.Put("/hello", func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Put("/hello", func(ctx *apis.Ctx) {
     data := ctx.Request.Data()
 
     ctx.Response.Body = data
-
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/api/api-route-all.mdx b/src/pages/reference/go/api/api-route-all.mdx
index 08efa05ee..2d6e5d663 100644
--- a/src/pages/reference/go/api/api-route-all.mdx
+++ b/src/pages/reference/go/api/api-route-all.mdx
@@ -7,35 +7,29 @@ Register a single handler for all HTTP Methods (GET, POST, PUT, DELETE, PATCH) o
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  customersRoute, err := nitric.NewApi("public").NewRoute("/customers")
-  if err != nil {
-    return
-  }
-
-  customersRoute.All(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    ctx.Response.Body = []byte("")
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	customersRoute := nitric.NewApi("public").NewRoute("/customers")
+
+	customersRoute.All(func(ctx *apis.Ctx) {
+		ctx.Response.Body = []byte("")
+	})
+
+	nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP methods on the given route.
+  </Property>
+  <Property name="options" type="...MethodOption">
+    Additional options for the route. See below.
   </Property>
 </Properties>
 
@@ -43,7 +37,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -64,127 +58,21 @@ When using the `all()` method to register a single function as the handler for a
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  customersRoute, err := nitric.NewApi("public").NewRoute("/customers")
-  if err != nil {
-    return
-  }
-
-  customersRoute.All(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    /* handle all requests */
-    return next(ctx)
-  })
-
-  customersRoute.Get(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-     /* this handler won't work */
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-## Examples
-
-### Register a method handler function
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  customersRoute, err := nitric.NewApi("public").NewRoute("/customers")
-  if err != nil {
-    return
-  }
-
-  customersRoute.All(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    ctx.Response.Body = []byte("")
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain services as a single method handler
-
-When multiple services are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  customersRoute, err := nitric.NewApi("private").NewRoute("/customers")
-  if err != nil {
-    return
-  }
-
-  customersRoute.All(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the request body
-
-For methods that include a request body, such as `POST` and `PUT`, you can access the body from the `ctx.Request.Data()` object.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  customersRoute, err := nitric.NewApi("public").NewRoute("/customers")
-  if err != nil {
-    return
-  }
-
-  customersRoute.All(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
+	customersRoute := nitric.NewApi("public").NewRoute("/customers")
 
-    ctx.Response.Body = data
+	customersRoute.All(func(ctx *apis.Ctx) {
+		/* handle all requests */
+	})
 
-    return next(ctx)
-  })
+	customersRoute.Get(func(ctx *apis.Ctx) {
+		/* this handler won't work */
+	})
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/api/api-route-delete.mdx b/src/pages/reference/go/api/api-route-delete.mdx
index 3bfa1d9b8..42675586f 100644
--- a/src/pages/reference/go/api/api-route-delete.mdx
+++ b/src/pages/reference/go/api/api-route-delete.mdx
@@ -7,35 +7,27 @@ Register a handler for HTTP DELETE requests to the route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.NewRoute("/hello").Delete(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.NewRoute("/hello").Delete(func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP request to the given route and
+    method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -46,7 +38,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -60,124 +52,3 @@ func main() {
     </Properties>
   </Property>
 </Properties>
-
-## Examples
-
-### Register a handler for DELETE requests
-
-```go
-api.NewRoute("/hello").Delete(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
-})
-```
-
-### Create a route with path params
-
-```go
-api.NewRoute("/hello/:name").Delete(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-})
-```
-
-### Create a route with no method security
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-  // Override the APIs security requirements with `WithNoMethodSecurity()`
-  api.NewRoute("/public").Delete(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    // Handle request
-    return next(ctx)
-  }, nitric.WithNoMethodSecurity())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello/:name").Delete(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the request body
-
-The DELETE request body is accessible using `ctx.Request.Data()`.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello").Delete(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
-
-    ctx.Response.Body = data
-
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-route-get.mdx b/src/pages/reference/go/api/api-route-get.mdx
index dca3f88f5..aee691ff0 100644
--- a/src/pages/reference/go/api/api-route-get.mdx
+++ b/src/pages/reference/go/api/api-route-get.mdx
@@ -7,35 +7,27 @@ Register a handler for HTTP GET requests to the route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.NewRoute("/hello").Get(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.NewRoute("/hello").Get(func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP request to the given route and
+    method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -46,7 +38,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -60,92 +52,3 @@ func main() {
     </Properties>
   </Property>
 </Properties>
-
-## Examples
-
-### Register a handler for GET requests
-
-```go
-api.NewRoute("/hello").Get(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
-})
-```
-
-### Create a route with path params
-
-```go
-api.NewRoute("/hello/:name").Get(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-})
-```
-
-### Create a route with no method security
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-  // Override the APIs security requirements with `WithNoMethodSecurity()`
-  api.NewRoute("/public").Get(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    // Handle request
-    return next(ctx)
-  }, nitric.WithNoMethodSecurity())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello/:name").Get(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-route-patch.mdx b/src/pages/reference/go/api/api-route-patch.mdx
index 09d7f72f5..d4cdd8ed3 100644
--- a/src/pages/reference/go/api/api-route-patch.mdx
+++ b/src/pages/reference/go/api/api-route-patch.mdx
@@ -7,35 +7,27 @@ Register a handler for HTTP PATCH requests to the route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.NewRoute("/hello").Patch(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.NewRoute("/hello").Patch(func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP request to the given route and
+    method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -46,7 +38,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -60,124 +52,3 @@ func main() {
     </Properties>
   </Property>
 </Properties>
-
-## Examples
-
-### Register a handler for PATCH requests
-
-```go
-api.NewRoute("/hello").Patch(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
-})
-```
-
-### Create a route with path params
-
-```go
-api.NewRoute("/hello/:name").Patch(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-})
-```
-
-### Create a route with no method security
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-  // Override the APIs security requirements with `WithNoMethodSecurity()`
-  api.NewRoute("/public").Patch(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    // Handle request
-    return next(ctx)
-  }, nitric.WithNoMethodSecurity())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello/:name").Patch(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the request body
-
-The PATCH request body is accessible using `ctx.Request.Data()`.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello").Patch(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
-
-    ctx.Response.Body = data
-
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-route-post.mdx b/src/pages/reference/go/api/api-route-post.mdx
index 45aef0765..760f206b6 100644
--- a/src/pages/reference/go/api/api-route-post.mdx
+++ b/src/pages/reference/go/api/api-route-post.mdx
@@ -7,35 +7,27 @@ Register a handler for HTTP POST requests to the route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+	api := nitric.NewApi("public")
 
-  api.NewRoute("/hello").Post(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
-  })
+	api.NewRoute("/hello").Post(func(ctx *apis.Ctx) {
+		ctx.Response.Body = []byte("Hello World")
+	})
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP request to the given route and
+    method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -46,7 +38,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -60,124 +52,3 @@ func main() {
     </Properties>
   </Property>
 </Properties>
-
-## Examples
-
-### Register a handler for POST requests
-
-```go
-api.NewRoute("/hello").Post(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
-})
-```
-
-### Create a route with path params
-
-```go
-api.NewRoute("/hello/:name").Post(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-})
-```
-
-### Create a route with no method security
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-  // Override the APIs security requirements with `WithNoMethodSecurity()`
-  api.NewRoute("/public").Post(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    // Handle request
-    return next(ctx)
-  }, nitric.WithNoMethodSecurity())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello/:name").Post(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the request body
-
-The POST request body is accessible using `ctx.Request.Data()`.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello").Post(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
-
-    ctx.Response.Body = data
-
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-route-put.mdx b/src/pages/reference/go/api/api-route-put.mdx
index 441217cbb..7001944d5 100644
--- a/src/pages/reference/go/api/api-route-put.mdx
+++ b/src/pages/reference/go/api/api-route-put.mdx
@@ -7,35 +7,27 @@ Register a handler for HTTP PUT requests to the route.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  api.NewRoute("/hello").Put(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
+  api.NewRoute("/hello").Put(func(ctx *apis.Ctx) {
     ctx.Response.Body = []byte("Hello World")
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="HttpMiddleware">
-    The middleware function to use as the handler for HTTP requests. If you want
-    to compose more than one middleware use `handler.ComposeHttpMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to handle all HTTP request to the given route and
+    method.
   </Property>
   <Property name="options" type="...MethodOption">
     Additional options for the route. See below.
@@ -46,7 +38,7 @@ func main() {
 
 <Properties>
   <Property name="WithNoMethodSecurity()" type="MethodOption">
-    Sets a base path for all the routes in the API.
+    Disables security on the method.
   </Property>
   <Property name="WithMethodSecurity()" type="MethodOption">
     Overrides a security rule from API defined JWT rules.
@@ -60,124 +52,3 @@ func main() {
     </Properties>
   </Property>
 </Properties>
-
-## Examples
-
-### Register a handler for PUT requests
-
-```go
-api.NewRoute("/hello").Put(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  ctx.Response.Body = []byte("Hello World")
-  return next(ctx)
-})
-```
-
-### Create a route with path params
-
-```go
-api.NewRoute("/hello/:name").Put(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-})
-```
-
-### Create a route with no method security
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  defaultOidcRule := nitric.OidcRule("user", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		nitric.WithSecurity(defaultOidcRule([]string{"products:read"})))
-	if err != nil {
-		return
-	}
-
-  // Override the APIs security requirements with `WithNoMethodSecurity()`
-  api.NewRoute("/public").Put(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    // Handle request
-    return next(ctx)
-  }, nitric.WithNoMethodSecurity())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Chain functions as a single method handler
-
-When multiple functions are provided they will be called as a chain. If one succeeds, it will move on to the next. This allows middleware to be composed into more complex handlers.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func handleRequest(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  name := ctx.Request.PathParams()["name"]
-  ctx.Response.Body = []byte("Hello " + name)
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("private")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello/:name").Put(handler.ComposeHttpMiddleware(authMiddleware, handleRequest))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the request body
-
-The PUT request body is accessible using `ctx.Request.Data()`.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  api.NewRoute("/hello").Put(func(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-    data := ctx.Request.Data()
-
-    ctx.Response.Body = data
-
-    return next(ctx)
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api-route.mdx b/src/pages/reference/go/api/api-route.mdx
index e64e54666..d143e81a7 100644
--- a/src/pages/reference/go/api/api-route.mdx
+++ b/src/pages/reference/go/api/api-route.mdx
@@ -7,23 +7,15 @@ Creates a new route (path) within an API.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
   route := api.NewRoute("/hello")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -38,93 +30,7 @@ func main() {
     middleware and handlers. See [create a route with path
     params](#create-a-route-with-path-params)
   </Property>
-  <Property name="middleware" type="...HttpMiddleware">
-    The middleware (code) that should be run on all requests to this route.
-    Useful for applying universal middleware such as CORS headers or Auth,
-    across an entire route from a single place.
+  <Property name="options" type="...RouteOption">
+    Additional options for the route.
   </Property>
 </Properties>
-
-## Examples
-
-### Create a route
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  route := api.NewRoute("/hello")
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Create a route with path params
-
-Route paths can include dynamic parameters. These values will automatically be parsed and provided in the context object for your middleware and handlers as a `string`.
-
-For example, if you have a customers path and you want to include a `customerId` param you would define the route like this.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  // Define route with customerId param
-  route := api.NewRoute("/customers/:customerId")
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Create a route with middleware
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
-}
-
-func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
-
-  route := api.NewRoute("/hello", authMiddleware)
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
diff --git a/src/pages/reference/go/api/api.mdx b/src/pages/reference/go/api/api.mdx
index a1fc2f6c4..82ddf0604 100644
--- a/src/pages/reference/go/api/api.mdx
+++ b/src/pages/reference/go/api/api.mdx
@@ -7,20 +7,13 @@ Creates a new HTTP API.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -52,7 +45,7 @@ func main() {
   </Property>
   <Property name="WithMiddleware()" type="ApiOption">
     <Properties nested>
-      <Property name="middleware" required type="HttpMiddleware">
+      <Property name="middleware" required type="nitric.Middleware[apis.Ctx]">
         The middleware (code) that should be run on all requests to the API.
         Useful for applying universal middleware such as CORS headers or Auth,
         across an entire API from a single place.
@@ -85,20 +78,13 @@ func main() {
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  api, err := nitric.NewApi("public")
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("public")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -106,41 +92,46 @@ func main() {
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
+func authMiddleware(next apis.Handler) apis.Handler {
+  return func(ctx *apis.Ctx) error {
+    if ctx.Request.Headers().Get("Authorization") == "" {
+      ctx.Response.Status = 401
+      ctx.Response.Body = []byte("Unauthorized")
+      return nil
+    }
+    // perform additional auth checks
+
+    return next(ctx)
+  }
 }
 
 func main() {
-  api, err := nitric.NewApi("private", nitric.WithMiddleware(authMiddleware))
-  if err != nil {
-    return
-  }
+  api := nitric.NewApi("private", apis.WithMiddleware(authMiddleware))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ### Define middleware
 
 ```go
-func authMiddleware(ctx *handler.HttpContext, next handler.HttpHandler) (*handler.HttpContext, error) {
-  // Perform auth validation
-  return next(ctx)
+func yourMiddleware(next apis.Handler) apis.Handler {
+  return func(ctx *apis.Ctx) error {
+    // Perform checks/actions prior to the route handler
+    err := next(ctx)
+    // Perform checks/actions after the route handler
+    return err
+  }
 }
 ```
 
 ### Notes
 
-Middleware functions are supplied an `HttpContext` object and a `next()` function which calls the next middleware in the chain.
+Middleware are higher-order functions that take a handler and return a handler. They can be used to perform actions before and after the route handler. Middleware can be used to perform actions such as logging, authentication, and error handling.
 
 ### Create an API with a base path
 
@@ -148,20 +139,14 @@ If you need to put all the routes in your api below a shared base path, you can
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-  v1Api, err := nitric.NewApi("public", nitric.WithPath("/api/v1/"))
-  if err != nil {
-    return
-  }
+	v1Api := nitric.NewApi("public", apis.WithPath("/api/v1/"))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
 
@@ -169,25 +154,23 @@ func main() {
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/apis"
 )
 
 func main() {
-	defaultSecurityRule := nitric.OidcRule("default", "https://example-issuer.com", []string{"YOUR-AUDIENCES"})
-
-	secureApi, err := nitric.NewApi(
-		"secure",
-		// apply the security definition to all routes in this API.
-		nitric.WithSecurity(defaultSecurityRule([]string{})),
-	)
-	if err != nil {
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  defaultOidcRule := apis.OidcRule(
+    "user",
+    "https://example-issuer.com/.well-known/openid-configuration",
+    []string{"YOUR-AUDIENCES"},
+  )
+
+  secureApi := nitric.NewApi(
+    "secure",
+    // apply the security definition to all routes in this API.
+    apis.WithSecurity(defaultOidcRule([]string{})),
+  )
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/keyvalue/keyvalue-delete.mdx b/src/pages/reference/go/keyvalue/keyvalue-delete.mdx
index eba734a33..aab531b07 100644
--- a/src/pages/reference/go/keyvalue/keyvalue-delete.mdx
+++ b/src/pages/reference/go/keyvalue/keyvalue-delete.mdx
@@ -7,27 +7,23 @@ Delete key from a key value store.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreDelete)
 
-	err = profiles.Delete(context.Background(), "profile-1a2b3c")
-	if err != nil {
-		fmt.Println(err)
-	}
+  err := profiles.Delete(context.Background(), "profile-1a2b3c")
+  if err != nil {
+    fmt.Println(err)
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -52,22 +48,18 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreDelete)
 
-	err = profiles.Delete(context.Background(), "profile-1a2b3c")
+	err := profiles.Delete(context.Background(), "profile-1a2b3c")
 	if err != nil {
 		fmt.Println(err)
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/keyvalue/keyvalue-get.mdx b/src/pages/reference/go/keyvalue/keyvalue-get.mdx
index e108c4618..c5a66b74e 100644
--- a/src/pages/reference/go/keyvalue/keyvalue-get.mdx
+++ b/src/pages/reference/go/keyvalue/keyvalue-get.mdx
@@ -7,25 +7,23 @@ Get a value from a key value store.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet)
-	if err != nil {
-		return
-	}
-
-	profile, err := profiles.Get(context.Background(), "profile-1a2b3c")
-	// do something with the profile
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet)
+
+  profile, err := profiles.Get(context.Background(), "profile-1a2b3c")
+  if err != nil {
+    // handle error
+  }
+  // do something with the profile
+
+  nitric.Run()
 }
 ```
 
@@ -46,24 +44,22 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet)
-	if err != nil {
-		return
-	}
-
-	profile, err := profiles.Get(context.Background(), "profile-1a2b3c")
-	// do something with the profile
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet)
+
+  profile, err := profiles.Get(context.Background(), "profile-1a2b3c")
+  if err != nil {
+    // handle error
+  }
+  // do something with the profile
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/keyvalue/keyvalue-keys.mdx b/src/pages/reference/go/keyvalue/keyvalue-keys.mdx
index 7bb0d4a26..df041e266 100644
--- a/src/pages/reference/go/keyvalue/keyvalue-keys.mdx
+++ b/src/pages/reference/go/keyvalue/keyvalue-keys.mdx
@@ -11,19 +11,16 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
 
 	keys, err := profiles.Keys(context.TODO())
 	if err != nil {
-		fmt.Println("Error getting keys: ", err)
-		return
+		// handle error
 	}
 
 	// Get all keys from a key value store
@@ -37,14 +34,23 @@ func main() {
 		fmt.Printf("Key: %s\n", key)
 	}
 
+	nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="prefix" type="string">
-    The prefix to filter keys by, if not provided all keys will be returned.
+  <Property name="options" type="...ScanKeysOption">
+    Options for the scan keys operation. See below.
+  </Property>
+</Properties>
+
+### Scan keys options
+
+<Properties>
+  <Property name="WithPrefix(prefix)" type="ScanKeysOption">
+    Filter keys by prefix.
   </Property>
 </Properties>
 
@@ -54,36 +60,35 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
-
-	keys, err := profiles.Keys(context.TODO())
-	if err != nil {
-		fmt.Println("Error getting keys: ", err)
-		return
-	}
-
-	// Get all keys from a key value store
-	for {
-		key, err := keys.Recv()
-		if err != nil {
-			// check if the stream has ended
-			break
-		}
-		// do something with the key
-		fmt.Printf("Key: %s\n", key)
-	}
-
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  keys, err := profiles.Keys(context.TODO())
+  if err != nil {
+    fmt.Println("Error getting keys: ", err)
+    return
+  }
+
+  // Get all keys from a key value store
+  for {
+    key, err := keys.Recv()
+    if err != nil {
+      // check if the stream has ended
+      break
+    }
+    // do something with the key
+    fmt.Printf("Key: %s\n", key)
+  }
+
+  nitric.Run()
 }
 ```
 
@@ -91,38 +96,35 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/api/keyvalue"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
-
-	// make function with keyvalue.ScanKeysOption type
-	keys, err := profiles.Keys(context.TODO(), keyvalue.WithPrefix("profile:"))
-	if err != nil {
-		fmt.Println("Error getting keys: ", err)
-		return
-	}
-
-	// Get all keys from a key value store
-	for {
-		key, err := keys.Recv()
-		if err != nil {
-			// check if the stream has ended
-			break
-		}
-		// do something with the key
-		fmt.Printf("Key: %s\n", key)
-	}
-
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  // make function with keyvalue.ScanKeysOption type
+  keys, err := profiles.Keys(context.TODO(), keyvalue.WithPrefix("profile:"))
+  if err != nil {
+    fmt.Println("Error getting keys: ", err)
+    return
+  }
+
+  // Get all keys from a key value store
+  for {
+    key, err := keys.Recv()
+    if err != nil {
+      // check if the stream has ended
+      break
+    }
+    // do something with the key
+    fmt.Printf("Key: %s\n", key)
+  }
+
+  nitric.Run()
 }
-
 ```
diff --git a/src/pages/reference/go/keyvalue/keyvalue-set.mdx b/src/pages/reference/go/keyvalue/keyvalue-set.mdx
index 029c69496..4d8842d44 100644
--- a/src/pages/reference/go/keyvalue/keyvalue-set.mdx
+++ b/src/pages/reference/go/keyvalue/keyvalue-set.mdx
@@ -7,29 +7,25 @@ Store a key value pair in a key value store.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreSet)
-	if err != nil {
-		return
-	}
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreSet)
 
-	err = profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
-		"name": "John Smith",
-	})
-	if err != nil {
-		fmt.Println(err)
-	}
+  err := profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
+    "name": "John Smith",
+  })
+  if err != nil {
+    fmt.Println(err)
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -57,24 +53,20 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreSet)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreSet)
 
-	err = profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
+	err := profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
 		"name": "John Smith",
 	})
 	if err != nil {
 		fmt.Println(err)
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/keyvalue/keyvalue.mdx b/src/pages/reference/go/keyvalue/keyvalue.mdx
index f4e03b902..6ebd5ef64 100644
--- a/src/pages/reference/go/keyvalue/keyvalue.mdx
+++ b/src/pages/reference/go/keyvalue/keyvalue.mdx
@@ -7,21 +7,14 @@ Creates a new key value store to get, set, and delete key value pairs.
 
 ```go
 import (
-	"fmt"
-
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -42,19 +35,19 @@ All Nitric resources provide access permissions you can use to specify the level
 
 ---
 
-**nitric.KvStoreGet**
+**keyvalue.KvStoreGet**
 
 This permission allows your service to get values from the key value store.
 
 ---
 
-**nitric.KvStoreSet**
+**keyvalue.KvStoreSet**
 
 This permission allows your service to set key value pairs in the key value store.
 
 ---
 
-**nitric.KvStoreDelete**
+**keyvalue.KvStoreDelete**
 
 This permission allows your service to delete key value pairs in the key value store.
 
@@ -66,21 +59,14 @@ This permission allows your service to delete key value pairs in the key value s
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
 
-	if err != nil {
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -89,24 +75,22 @@ func main() {
 ```go
 import (
 	"context"
-	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet)
 
 	profile, err := profiles.Get(context.Background(), "profile-1a2b3c")
+	if err != nil {
+		// handle error
+	}
 	// do something with the profile
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -118,25 +102,21 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreSet)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreSet)
 
-	err = profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
+	err := profiles.Set(context.Background(), "profile-1a2b3c", map[string]interface{}{
 		"name": "John Smith",
 	})
 	if err != nil {
 		fmt.Println(err)
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -148,57 +128,54 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
 	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
+	profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreDelete)
 
-	err = profiles.Delete(context.Background(), "profile-1a2b3c")
+	err := profiles.Delete(context.Background(), "profile-1a2b3c")
 	if err != nil {
 		fmt.Println(err)
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
-
 ```
 
 ### Get all keys from a key value store
 
 ```go
 import (
-	"context"
-	"fmt"
-	"io"
-	"github.com/nitrictech/go-sdk"
+  "context"
+  "fmt"
+
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
 )
 
 func main() {
-	// Initialize the KV service
-	profiles, err := nitric.NewKv("profiles").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
-
-	// Get all keys from a key value store
-	for {
-		key, err := keys.Recv()
-		if err != nil {
-			// check if the stream has ended
-			if err == io.EOF {
-				break
-			}
-			return nil, err
-		}
-		// do something with the key
-		fmt.Printf("Key: %s\n", key)
-	}
-
+  // Initialize the KV service
+  profiles := nitric.NewKv("profiles").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  keys, err := profiles.Keys(context.TODO())
+  if err != nil {
+    fmt.Println("Error getting keys: ", err)
+    return
+  }
+
+  // Get all keys from a key value store
+  for {
+    key, err := keys.Recv()
+    if err != nil {
+      // check if the stream has ended
+      break
+    }
+    // do something with the key
+    fmt.Printf("Key: %s\n", key)
+  }
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/queues/queue-dequeue.mdx b/src/pages/reference/go/queues/queue-dequeue.mdx
index 05a242b07..1ffb94eb3 100644
--- a/src/pages/reference/go/queues/queue-dequeue.mdx
+++ b/src/pages/reference/go/queues/queue-dequeue.mdx
@@ -7,35 +7,31 @@ Dequeue messages.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueDequeue)
-	if err != nil {
-		return
-	}
+  queue := nitric.NewQueue("queue-name").Allow(queues.QueueDequeue)
 
-	ctx := context.TODO()
+  ctx := context.TODO()
 
-	// dequeue up to 10 messages
-	messages, err := queue.Dequeue(ctx, 10)
-	if err != nil {
-		return
-	}
+  // dequeue up to 10 messages
+  messages, err := queue.Dequeue(ctx, 10)
+  if err != nil {
+    return
+  }
 
-	for _, message := range messages {
-		fmt.Println("Message: ", message.Message())
+  for _, message := range messages {
+    fmt.Println("Message: ", message.Message())
 
-		message.Complete(ctx)
-	}
+    message.Complete(ctx)
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -81,34 +77,30 @@ This means calls to dequeue will return between 0 and _depth_ tasks.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueDequeue)
-	if err != nil {
-		return
-	}
+  queue := nitric.NewQueue("queue-name").Allow(queues.QueueDequeue)
 
-	ctx := context.TODO()
+  ctx := context.TODO()
 
-	// dequeue up to 10 messages
-	messages, err := queue.Dequeue(ctx, 10)
-	if err != nil {
-		return
-	}
+  // dequeue up to 10 messages
+  messages, err := queue.Dequeue(ctx, 10)
+  if err != nil {
+    return
+  }
 
-	for _, message := range messages {
-		fmt.Println("Message: ", message.Message())
+  for _, message := range messages {
+    fmt.Println("Message: ", message.Message())
 
-		message.Complete(ctx)
-	}
+    message.Complete(ctx)
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/queues/queue-enqueue.mdx b/src/pages/reference/go/queues/queue-enqueue.mdx
index 522b64c61..c8a9ae38c 100644
--- a/src/pages/reference/go/queues/queue-enqueue.mdx
+++ b/src/pages/reference/go/queues/queue-enqueue.mdx
@@ -11,14 +11,11 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueEnqueue, nitric.QueueDequeue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	queue := nitric.NewQueue("queue-name").Allow(queues.QueueEnqueue, queues.QueueDequeue)
 
 	messages := []map[string]interface{}{
 		{
@@ -32,9 +29,7 @@ func main() {
 		return
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -55,42 +50,37 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueEnqueue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	messages := []map[string]interface{}{
-		{
-			"type":    "email",
-			"to":      "hello@example.com",
-			"subject": "Notification",
-			"message": "A notification from Nitric",
-		},
-		{
-			"type":    "SMS",
-			"to":      "+17200000000",
-			"message": "A text message from Nitric",
-		},
-	}
-
-	failedMessages, err := queue.Enqueue(context.TODO(), messages)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  queue := nitric.NewQueue("queue-name").Allow(queues.QueueEnqueue)
+
+  messages := []map[string]interface{}{
+    {
+      "type":    "email",
+      "to":      "hello@example.com",
+      "subject": "Notification",
+      "message": "A notification from Nitric",
+    },
+    {
+      "type":    "SMS",
+      "to":      "+17200000000",
+      "message": "A text message from Nitric",
+    },
+  }
+
+  failedMessages, err := queue.Enqueue(context.TODO(), messages)
+  if err != nil {
+    fmt.Println(err)
+    return
+  }
+
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/queues/queue.mdx b/src/pages/reference/go/queues/queue.mdx
index 0c565d8e7..e94a10e2f 100644
--- a/src/pages/reference/go/queues/queue.mdx
+++ b/src/pages/reference/go/queues/queue.mdx
@@ -7,21 +7,14 @@ Creates a new Queue to send and receive asynchronous tasks.
 
 ```go
 import (
-	"fmt"
-
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueEnqueue, nitric.QueueDequeue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	queue := nitric.NewQueue("queue-name").Allow(queues.QueueEnqueue, queues.QueueDequeue)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -64,21 +57,14 @@ In most instances, code should either enqueue or dequeue from a queue, usually n
 
 ```go
 import (
-	"fmt"
-
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueEnqueue, nitric.QueueDequeue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	queue := nitric.NewQueue("queue-name").Allow(queues.QueueEnqueue, queues.QueueDequeue)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -90,16 +76,17 @@ import (
 	"fmt"
 
 	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueEnqueue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	queue := nitric.NewQueue("queue-name").Allow(queues.QueueEnqueue, queues.QueueDequeue)
 
-	messages := []map[string]interface{}{}
+	messages := []map[string]interface{}{
+		{
+			"message": "hello world",
+		},
+	}
 
 	failedMessages, err := queue.Enqueue(context.TODO(), messages)
 	if err != nil {
@@ -107,9 +94,7 @@ func main() {
 		return
 	}
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+	nitric.Run()
 }
 ```
 
@@ -117,27 +102,30 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/queues"
 )
 
 func main() {
-	queue, err := nitric.NewQueue("queue-name").Allow(nitric.QueueDequeue)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+  queue := nitric.NewQueue("queue-name").Allow(queues.QueueDequeue)
 
-	tasks, err := queue.Dequeue(context.TODO(), 10)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+  ctx := context.TODO()
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // dequeue up to 10 messages
+  messages, err := queue.Dequeue(ctx, 10)
+  if err != nil {
+    return
+  }
+
+  for _, message := range messages {
+    fmt.Println("Message: ", message.Message())
+
+    message.Complete(ctx)
+  }
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/schedule/schedule-cron.mdx b/src/pages/reference/go/schedule/schedule-cron.mdx
index 4b7467847..e58648181 100644
--- a/src/pages/reference/go/schedule/schedule-cron.mdx
+++ b/src/pages/reference/go/schedule/schedule-cron.mdx
@@ -7,22 +7,15 @@ Sets the cron expressions that determines when the schedule triggers and a callb
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  nitric.NewSchedule("archive-data").Cron("0 1 1 * *", func (ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
-    fmt.Println("archiving data")
+	nitric.NewSchedule("archive-data").Cron("0 1 1 * *", func() {
+		// code which archives data
+	})
 
-    return ctx, nil
-  })
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+	nitric.Run()
 }
 ```
 
@@ -33,9 +26,9 @@ func main() {
     The expression that sets when the schedule will be triggered. This value
     should be a standard 5 value Unix cron expression, e.g., '0 1 1 * *'.
   </Property>
-  <Property name="middleware" required type="EventMiddleware">
-    One or more callback functions to use as the handler which will run on the
-    defined frequency.
+  <Property name="handler" required type="interface{}">
+    The callback function to use as the handler which will run on the defined
+    frequency.
   </Property>
 </Properties>
 
@@ -47,58 +40,20 @@ func main() {
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
   // every 15 minutes
-  nitric.NewSchedule("check for updates").Cron("0/15 * * * *", func (ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("check for updates").Cron("0/15 * * * *", func () {
     fmt.Println("checking for updates")
-
-    return ctx, nil
   })
 
   // at 1:00am on the 1st of every month
-  nitric.NewSchedule("delete stale data").Cron("0 1 1 * *", func (ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("delete stale data").Cron("0 1 1 * *", func () {
     fmt.Println("deleting stale data")
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Create a Schedule with multiple middleware/handlers
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func generateReport(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-  // generate report
-
-  return next(ctx)
-}
-
-func sendNotification(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-  // send notification with the report
-
-  return next(ctx)
-}
-
-func main() {
-  nitric.NewSchedule("check for updates").Cron("0 1 1 * *", handler.ComposeIntervalMiddleware(generateReport, sendNotification))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/schedule/schedule-every.mdx b/src/pages/reference/go/schedule/schedule-every.mdx
index c38004016..13d3e752b 100644
--- a/src/pages/reference/go/schedule/schedule-every.mdx
+++ b/src/pages/reference/go/schedule/schedule-every.mdx
@@ -7,23 +7,16 @@ Sets the frequency and one or many handlers to be triggered.
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
   // Create a schedule that runs every 3 minutes
-  nitric.NewSchedule("send reminder").Every("3 minutes", func(ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("send reminder").Every("3 minutes", func() {
     // code which sends a reminder
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -34,9 +27,9 @@ func main() {
     The rate to run the schedule, e.g., '7 days'. All rates accept a number and
     a frequency. Valid frequencies are 'days', 'hours', or 'minutes'.
   </Property>
-  <Property name="middleware" required type="EventMiddleware">
-    One or more middleware functions to use as the handler which will run on the
-    defined frequency.
+  <Property name="handler" required type="interface{}">
+    The callback function to use as the handler which will run on the defined
+    frequency.
   </Property>
 </Properties>
 
@@ -46,53 +39,15 @@ func main() {
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
   // Create a schedule that runs every 3 minutes
-  nitric.NewSchedule("send reminder").Every("3 minutes", func(ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("send reminder").Every("3 minutes", func() {
     // code which sends a reminder
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Create a Schedule with multiple middleware/handlers
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func generateReport(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-  // generate report
-
-  return next(ctx)
-}
-
-func sendNotification(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-  // send notification with the report
-
-  return next(ctx)
-}
-
-func main() {
-  nitric.NewSchedule("aggregate data").Every("3 days", handler.ComposeIntervalMiddleware(generateReport, sendNotification))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/schedule/schedule.mdx b/src/pages/reference/go/schedule/schedule.mdx
index dfcabd0b5..d64b47f2d 100644
--- a/src/pages/reference/go/schedule/schedule.mdx
+++ b/src/pages/reference/go/schedule/schedule.mdx
@@ -9,20 +9,15 @@ Creates a new Schedule to run a function on a defined frequency.
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  nitric.NewSchedule("aggregate-data").Every("3 days", func(ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("aggregate-data").Every("3 days", func() {
     fmt.Println("aggregating data")
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -38,7 +33,6 @@ func main() {
 ### Notes
 
 - Schedules do not require access permissions to be specified.
-
 - During local development schedules can be triggered manually from the local development dashboard
 
 ## Examples
@@ -49,25 +43,18 @@ func main() {
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  nitric.NewSchedule("send-reminder").Every("1 day", func(ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("send-reminder").Every("1 day", func() {
     fmt.Println("sending data")
-
-    return ctx, nil
   })
 
-  nitric.NewSchedule("archive-data").Cron("0 1 1 * *", func (ctx *handler.IntervalContext, _ handler.IntervalHandler) (*handler.IntervalContext, error) {
+  nitric.NewSchedule("archive-data").Cron("0 1 1 * *", func() {
     fmt.Println("archiving data")
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/secrets/secret-version-access.mdx b/src/pages/reference/go/secrets/secret-access-version.mdx
similarity index 54%
rename from src/pages/reference/go/secrets/secret-version-access.mdx
rename to src/pages/reference/go/secrets/secret-access-version.mdx
index eeb312692..8c06b3c45 100644
--- a/src/pages/reference/go/secrets/secret-version-access.mdx
+++ b/src/pages/reference/go/secrets/secret-access-version.mdx
@@ -1,33 +1,30 @@
 export const description =
   "Reference for Nitric's Go library - Retrieves the value from a version of a secret."
 
-# Go - Secret.Version.Access()
+# Go - Secret.AccessVersion()
 
 Retrieves the value from a version of a secret.
 
 ```go
 import (
+  "context"
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
 
-  value, err := secret.Latest().Access(context.TODO())
+  value, err := secret.AccessVersion(context.TODO(), "latest")
   if err != nil {
     return
   }
 
   fmt.Println(value.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -37,6 +34,9 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
+  <Property name="version" required type="string">
+    The ID of the secret version to access
+  </Property>
 </Properties>
 
 ## Examples
@@ -45,27 +45,24 @@ func main() {
 
 ```go
 import (
+  "context"
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
 
-  value, err := secret.Latest().Access(context.TODO())
+  value, err := secret.AccessVersion(context.TODO(), "latest")
   if err != nil {
     return
   }
 
   fmt.Println(value.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -77,15 +74,13 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
 
-  version, err := secret.Version("the-version-id").Access(context.TODO())
+  version, err := secret.AccessVersion(context.TODO(), "the-version-id")
   if err != nil {
     fmt.Println(err)
     return
@@ -93,8 +88,6 @@ func main() {
 
   fmt.Println(version.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/secrets/secret-access.mdx b/src/pages/reference/go/secrets/secret-access.mdx
new file mode 100644
index 000000000..05aca7168
--- /dev/null
+++ b/src/pages/reference/go/secrets/secret-access.mdx
@@ -0,0 +1,79 @@
+export const description =
+  "Reference for Nitric's Go library - Returns a reference to the latest version of a secret, regardless of that version's ID."
+
+# Go - Secret.Access()
+
+Returns a the value of the latest iteration of a secret.
+
+```go
+import (
+	"context"
+
+	"github.com/nitrictech/go-sdk/nitric"
+	"github.com/nitrictech/go-sdk/nitric/secrets"
+)
+
+func main() {
+	secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
+
+	latestSecret := secret.Access(context.TODO())
+
+	nitric.Run()
+}
+```
+
+## Notes
+
+`Access()` is most useful when you always want the most recent secret values from the secrets manager. Database credentials and API keys are good examples of secrets where the latest value is usually what you want.
+
+For symmetric encryption, you'll need to retrieve the version of the secret used to _encrypt_ a value when you try to _decrypt_ it again. In those cases `Access()` isn't a good choice, use [AccessVersion()](./secret-access-version) instead.
+
+## Examples
+
+### Get a reference to the latest secret version
+
+```go
+import (
+  "context"
+
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
+)
+
+func main() {
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
+
+  latest := secret.Access(context.TODO())
+
+  nitric.Run()
+}
+```
+
+### Access the latest value of a secret
+
+```go
+import (
+  "context"
+  "fmt"
+
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
+)
+
+func main() {
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
+
+  value, err := secret.Access(context.TODO())
+  if err != nil {
+    return
+  }
+
+  fmt.Println(value.AsString())
+
+  nitric.Run()
+}
+```
+
+<Note>
+  See [Secret.AccessVersion()](./secret-access-version) for more details.
+</Note>
diff --git a/src/pages/reference/go/secrets/secret-latest.mdx b/src/pages/reference/go/secrets/secret-latest.mdx
deleted file mode 100644
index e9f0b2118..000000000
--- a/src/pages/reference/go/secrets/secret-latest.mdx
+++ /dev/null
@@ -1,90 +0,0 @@
-export const description =
-  "Reference for Nitric's Go library - Returns a reference to the latest version of a secret, regardless of that version's ID."
-
-# Go - Secret.Latest()
-
-Returns a reference to the `latest` version of a secret, regardless of that version's ID.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  latest := secret.Latest()
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-## Notes
-
-`Latest()` is most useful when you always want the most recent secret values from the secrets manager. Database credentials and API keys are good examples of secrets where the latest value is usually what you want.
-
-For symmetric encryption, you'll need to retrieve the version of the secret used to _encrypt_ a value when you try to _decrypt_ it again. In those cases `Latest()` isn't a good choice, use [version()](./secret-version) instead.
-
-## Examples
-
-### Get a reference to the latest secret version
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  latest := secret.Latest()
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the latest value of a secret
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  value, err := secret.Latest().Access(context.TODO())
-  if err != nil {
-    return
-  }
-
-  fmt.Println(value.AsString())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-<Note>
-  See [Secret.Version().Access()](./secret-version-access) for more details.
-</Note>
diff --git a/src/pages/reference/go/secrets/secret-put.mdx b/src/pages/reference/go/secrets/secret-put.mdx
index a8e3c6905..d98d497ec 100644
--- a/src/pages/reference/go/secrets/secret-put.mdx
+++ b/src/pages/reference/go/secrets/secret-put.mdx
@@ -3,30 +3,25 @@ export const description =
 
 # Go - Secret.Put()
 
-Store a new secret value, creating a new [version](./secret-version) to store the value.
+Store a new secret value.
 
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretPut)
 
-  versionRef, err := secret.Put(context.TODO(), []byte("content"))
+  versionName, err := secret.Put(context.TODO(), []byte("content"))
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -52,31 +47,26 @@ A new secret version is always created when calling `Put()`, the versions will a
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretPut)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretPut)
 
-  versionRef, err := secret.Put(context.TODO(), []byte("content"))
+  versionName, err := secret.Put(context.TODO(), []byte("content"))
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ### Get the id of a new secret version
 
-Calling `put()` returns a promise to a reference to the new secret version. Storing the ID of the new version can be useful if you need to retrieve that specific value again in future using [version.access()](./secret-version-access)
+Calling `put()` returns the ID of the new secret version. Storing the ID of the new version can be useful if you need to retrieve that specific value again in future using [secret.access()](./secret-access)
 
 ```go
 import (
@@ -84,23 +74,19 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretAccess)
 
-  versionRef, err := secret.Put(context.TODO(), []byte("content"))
+  versionName, err := secret.Put(context.TODO(), []byte("content"))
   if err != nil {
     return
   }
 
-  fmt.Println(versionRef.Version())
+  fmt.Println(versionName)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/secrets/secret-version.mdx b/src/pages/reference/go/secrets/secret-version.mdx
deleted file mode 100644
index 9a07944f7..000000000
--- a/src/pages/reference/go/secrets/secret-version.mdx
+++ /dev/null
@@ -1,94 +0,0 @@
-export const description =
-  "Reference for Nitric's Go library - Returns a reference to a known version of a secret."
-
-# Go - Secret.Version()
-
-Returns a reference to a known version of a secret.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  version := secret.Version("the-version-id")
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-## Parameters
-
-<Properties>
-  <Property name="version" required type="string">
-    The version ID. This value is returned from [secret.Put()](./secret-put).
-  </Property>
-</Properties>
-
-## Examples
-
-### Return a reference to a known secret version
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  version := secret.Version("the-version-id")
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Access the value of a known secret version
-
-```go
-import (
-  "context"
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  version, err := secret.Version("the-version-id").Access(context.TODO())
-  if err != nil {
-    fmt.Println(err)
-    return
-  }
-
-  fmt.Println(version.AsString())
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### See also
-
-- [Secret.Version().Access()](./secret-version-access)
diff --git a/src/pages/reference/go/secrets/secret.mdx b/src/pages/reference/go/secrets/secret.mdx
index e6e87c963..11044d75a 100644
--- a/src/pages/reference/go/secrets/secret.mdx
+++ b/src/pages/reference/go/secrets/secret.mdx
@@ -7,20 +7,14 @@ Creates a reference to a secret in the secrets manager.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretPut, nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretPut, secrets.SecretAccess)
+
+  nitric.Run()
 }
 ```
 
@@ -59,26 +53,19 @@ This permission allows your code to retrieve secret values.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-  secret, err := nitric.NewSecret("secret-name").Allow(nitric.SecretPut, nitric.SecretAccess)
-  if err != nil {
-    return
-  }
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  secret := nitric.NewSecret("secret-name").Allow(secrets.SecretPut, secrets.SecretAccess)
+
+  nitric.Run()
 }
 ```
 
 ### See also
 
 - [Secret.Put()](./secret-put)
-- [Secret.Version()](./secret-version)
-- [Secret.Latest()](./secret-latest)
-- [Secret.Version().Access()](./secret-version-access)
+- [Secret.AccessVersion()](./secret-access-version)
+- [Secret.Access()](./secret-access)
diff --git a/src/pages/reference/go/storage/bucket-file-delete.mdx b/src/pages/reference/go/storage/bucket-delete.mdx
similarity index 55%
rename from src/pages/reference/go/storage/bucket-file-delete.mdx
rename to src/pages/reference/go/storage/bucket-delete.mdx
index 8748e3d20..36dfd9209 100644
--- a/src/pages/reference/go/storage/bucket-file-delete.mdx
+++ b/src/pages/reference/go/storage/bucket-delete.mdx
@@ -8,25 +8,20 @@ Delete a file from a bucket.
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketDelete)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketDelete)
 
-  err = bucket.File("cat.png").Delete(context.TODO())
+  err := bucket.Delete(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -36,6 +31,9 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
+  <Property name="key" required type="string">
+    The key of the file to delete.
+  </Property>
 </Properties>
 
 ## Examples
@@ -45,24 +43,19 @@ func main() {
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketDelete)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketDelete)
 
-  err = bucket.File("cat.png").Delete(context.TODO())
+  err := bucket.Delete(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/storage/bucket-file-downloadurl.mdx b/src/pages/reference/go/storage/bucket-downloadurl.mdx
similarity index 60%
rename from src/pages/reference/go/storage/bucket-file-downloadurl.mdx
rename to src/pages/reference/go/storage/bucket-downloadurl.mdx
index 42127d959..afe431b01 100644
--- a/src/pages/reference/go/storage/bucket-file-downloadurl.mdx
+++ b/src/pages/reference/go/storage/bucket-downloadurl.mdx
@@ -1,32 +1,27 @@
 export const description =
   "Reference for Nitric's Go library - Get a download url for a file from a bucket."
 
-# Go - Bucket.File.DownloadUrl()
+# Go - Bucket.DownloadUrl()
 
 Create a download url for a file within a bucket.
 
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketRead)
 
-  uploadUrl, err := bucket.File("cat.png").DownloadUrl(context.TODO(), 3600)
+  downloadUrl, err := bucket.DownloadUrl(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -36,8 +31,11 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
-  <Property name="expiry" required type="int">
-    Seconds until link expiry. Maximum of `604800` (7 days).
+  <Property name="key" required type="string">
+    The key of the file to create a download url for.
+  </Property>
+  <Property name="...opts" required type="storage.PresignUrlOption">
+    Options to configure the download url.
   </Property>
 </Properties>
 
@@ -51,6 +49,7 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
@@ -59,14 +58,12 @@ func main() {
     return
   }
 
-  uploadUrl, err := bucket.File("cat.png").DownloadUrl(context.TODO(), 300)
+  downloadUrl, err := bucket.File("cat.png").DownloadUrl(context.TODO(), "cat.png", storage.WithPresignUrlExpiry(time.Minute*5))
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -77,7 +74,7 @@ import (
   "context"
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
+  "github.com/nitrictech/go-sdk/nitric/apis"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
@@ -92,22 +89,18 @@ func main() {
     return
   }
 
-  api.Get("/images/:id", func(ctx *handler.HttpContext, _ handler.HttpHandler) (*handler.HttpContext, error) {
+  api.Get("/images/:id", func(ctx *apis.Ctx) {
     id := ctx.Request.PathParams()["id"]
 
-    downloadUrl, err := bucket.File(id).DownloadUrl(context.TODO(), 600)
+    downloadUrl, err := bucket.DownloadUrl(context.TODO(), id)
     if err != nil {
       return ctx, err
     }
 
     ctx.Response.Headers["Location"] = []string{downloadUrl}
     ctx.Response.Status = 303
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/storage/bucket-file.mdx b/src/pages/reference/go/storage/bucket-file.mdx
deleted file mode 100644
index e0d671618..000000000
--- a/src/pages/reference/go/storage/bucket-file.mdx
+++ /dev/null
@@ -1,47 +0,0 @@
-export const description =
-  "Reference for Nitric's Go library - Create a reference to a file within a bucket."
-
-# Go - Bucket.File()
-
-Create a reference to a file within a bucket.
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
-
-  file := bucket.File("cat.png")
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-## Parameters
-
-<Properties>
-  <Property name="name" required type="string">
-    The unique name/reference to the file.
-  </Property>
-</Properties>
-
-### Notes
-
-The file does not need to exist, only a reference to that file is being created.
-
-## Available Operations
-
-- [File.Read()](./bucket-file-read)
-- [File.Write()](./bucket-file-write)
-- [File.Delete()](./bucket-file-delete)
-- [File.GetDownloadUrl()](./bucket-file-downloadurl)
-- [File.GetUploadUrl()](./bucket-file-uploadurl)
diff --git a/src/pages/reference/go/storage/bucket-files.mdx b/src/pages/reference/go/storage/bucket-listfiles.mdx
similarity index 51%
rename from src/pages/reference/go/storage/bucket-files.mdx
rename to src/pages/reference/go/storage/bucket-listfiles.mdx
index 52fb8ea5a..042276873 100644
--- a/src/pages/reference/go/storage/bucket-files.mdx
+++ b/src/pages/reference/go/storage/bucket-listfiles.mdx
@@ -1,32 +1,35 @@
 export const description =
   "Reference for Nitric's Go library - Get a list of file references for files that exist in the bucket."
 
-# Go - Bucket.Files()
+# Go - Bucket.ListFiles()
 
-Get a list of file references for files that exist in the bucket.
+Get a list of file keys for files that exist in the bucket.
 
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketRead)
 
-  files, err := bucket.Files(context.TODO())
+  files, err := bucket.ListFiles(context.TODO())
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
+  for _, file := range files {
+    contents, err := bucket.Read(context.TODO(), file)
+    if err != nil {
+      continue
+    }
+    // Do something with the file contents
   }
+
+  nitric.Run()
 }
 ```
 
@@ -48,32 +51,24 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketRead)
 
   ctx := context.TODO()
 
-  files, err := bucket.Files(ctx)
+  files, err := bucket.ListFiles(ctx)
   if err != nil {
     fmt.Println(err)
     return
   }
 
   for _, file := range files {
-    file.Delete(ctx)
+    bucket.Delete(ctx, file)
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
-
-## Notes
-
-This method returns a list of [File](./bucket-file) references that exist on the bucket.
diff --git a/src/pages/reference/go/storage/bucket-on.mdx b/src/pages/reference/go/storage/bucket-on.mdx
index 673541f87..339537aec 100644
--- a/src/pages/reference/go/storage/bucket-on.mdx
+++ b/src/pages/reference/go/storage/bucket-on.mdx
@@ -10,44 +10,35 @@ import (
   "context"
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
   assets := nitric.NewBucket("assets")
 
-  readableAssets, err := nitric.NewBucket("assets").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  readableAssets := nitric.NewBucket("assets").Allow(storage.BucketRead)
 
-  assets.On(handler.DeleteNotification, "*", func(ctx *handler.BlobEventContext, _ handler.BlobEventHandler) (*handler.BlobEventContext, error) {
+  assets.On(storage.DeleteNotification, "*", func(ctx *storage.Ctx) {
     fmt.Printf("a file named %s was deleted\n", ctx.Request.Key())
-
-    return ctx, nil
   })
 
-  assets.On(handler.WriteNotification, "/images/cat", func(ctx *handler.BlobEventContext, _ handler.BlobEventHandler) (*handler.BlobEventContext, error) {
+  assets.On(storage.WriteNotification, "/images/cat", func(ctx *storage.Ctx) {
     fmt.Printf("a cat image was written")
-
-    return ctx, nil
   })
 
-  assets.On(handler.WriteNotification, "/images/dog", func(ctx *handler.BlobEventContext, _ handler.BlobEventHandler) (*handler.BlobEventContext, error) {
-    dogImage, err := readableAssets.File(ctx.Request.Key()).Read(context.TODO())
+  assets.On(storage.WriteNotification, "/images/dog", func(ctx *storage.Ctx) error {
+    dogImage, err := readableAssets.Read(context.TODO(), ctx.Request.Key())
     if err != nil {
-      return ctx, err
+      return err
     }
 
     fmt.Println(dogImage)
 
-    return ctx, nil
+    return nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -67,9 +58,8 @@ func main() {
     filters overlap across notifications, an error will be thrown when
     registering the resource.
   </Property>
-  <Property name="middleware" required type="BlobEventMiddleware">
-    The middleware (code) to be triggered by the bucket notification being
-    triggered.
+  <Property name="handler" required type="interface{}">
+    The callback function to be triggered when bucket events occur.
   </Property>
 </Properties>
 
@@ -77,11 +67,11 @@ func main() {
 
 **WriteNotification**
 
-Run when a file in the bucket is created using: `File.Write()`
+Run when a file in the bucket is created using: `Bucket.Write()`
 
 **DeleteNotification**
 
-Run when a file in the bucket is deleted using: `File.Delete()`
+Run when a file in the bucket is deleted using: `Bucket.Delete()`
 
 ### Trigger type cloud mapping
 
diff --git a/src/pages/reference/go/storage/bucket-file-read.mdx b/src/pages/reference/go/storage/bucket-read.mdx
similarity index 58%
rename from src/pages/reference/go/storage/bucket-file-read.mdx
rename to src/pages/reference/go/storage/bucket-read.mdx
index ebd07a2aa..d9dc88ae9 100644
--- a/src/pages/reference/go/storage/bucket-file-read.mdx
+++ b/src/pages/reference/go/storage/bucket-read.mdx
@@ -1,7 +1,7 @@
 export const description =
   "Reference for Nitric's Go library - Read the contents of a file from a bucket."
 
-# Go - Bucket.File.Read()
+# Go - Bucket.Read()
 
 Read the contents of a file from a bucket.
 
@@ -11,24 +11,20 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketRead)
 
-  contents, err := bucket.File("cat.png").Read(context.TODO())
+  contents, err := bucket.Read(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
   fmt.Println(contents)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -38,6 +34,9 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
+  <Property name="key" required type="string">
+    The key of the file to read
+  </Property>
 </Properties>
 
 ## Examples
@@ -50,23 +49,19 @@ import (
   "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketRead)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketRead)
 
-  contents, err := bucket.File("cat.png").Read(context.TODO())
+  contents, err := bucket.Read(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
   fmt.Println(contents)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/storage/bucket-file-uploadurl.mdx b/src/pages/reference/go/storage/bucket-uploadurl.mdx
similarity index 52%
rename from src/pages/reference/go/storage/bucket-file-uploadurl.mdx
rename to src/pages/reference/go/storage/bucket-uploadurl.mdx
index 83f6cadee..03978c2f4 100644
--- a/src/pages/reference/go/storage/bucket-file-uploadurl.mdx
+++ b/src/pages/reference/go/storage/bucket-uploadurl.mdx
@@ -8,25 +8,20 @@ Create an upload URL for a file within a bucket.
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketWrite)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketWrite)
 
-  uploadUrl, err := bucket.File("cat.png").UploadUrl(context.TODO(), 600)
+  uploadUrl, err := bucket.UploadUrl(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -36,8 +31,11 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
-  <Property name="expiry" required type="int">
-    Seconds until link expiry. Maximum of `604800` (7 days).
+  <Property name="key" required type="string">
+    The key of the file to create an upload url for.
+  </Property>
+  <Property name="...opts" required type="storage.PresignUrlOption">
+    Options to configure the upload url.
   </Property>
 </Properties>
 
@@ -48,24 +46,19 @@ func main() {
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketWrite)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketWrite)
 
-  uploadUrl, err := bucket.File("cat.png").UploadUrl(context.TODO(), 600)
+  uploadUrl, err := bucket.UploadUrl(context.TODO(), "cat.png")
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/storage/bucket-file-write.mdx b/src/pages/reference/go/storage/bucket-write.mdx
similarity index 57%
rename from src/pages/reference/go/storage/bucket-file-write.mdx
rename to src/pages/reference/go/storage/bucket-write.mdx
index f2cbe2b32..26fae0790 100644
--- a/src/pages/reference/go/storage/bucket-file-write.mdx
+++ b/src/pages/reference/go/storage/bucket-write.mdx
@@ -8,25 +8,20 @@ Write a file to a bucket.
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketWrite)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketWrite)
 
-  err = bucket.File("cat.png").Write(context.TODO(), []byte("contents"))
+  err := bucket.Write(context.TODO(), "cat.png", []byte("contents"))
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -36,6 +31,9 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
+  <Property name="key" required type="string">
+    The key of the file to write.
+  </Property>
   <Property name="data" required type="[]byte">
     The data to write to the file.
   </Property>
@@ -48,24 +46,19 @@ func main() {
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketWrite)
-  if err != nil {
-    return
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketWrite)
 
-  err = bucket.File("cat.png").Write(context.TODO(), []byte("contents"))
+  err := bucket.Write(context.TODO(), "cat.png", []byte("contents"))
   if err != nil {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/storage/bucket.mdx b/src/pages/reference/go/storage/bucket.mdx
index 52e07de62..322c39a77 100644
--- a/src/pages/reference/go/storage/bucket.mdx
+++ b/src/pages/reference/go/storage/bucket.mdx
@@ -7,20 +7,14 @@ Create a new bucket for storing and retrieving files.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-  bucket, err := nitric.NewBucket("bucket-name").Allow(nitric.BucketWrite, nitric.BucketRead, nitric.BucketDelete)
-  if err != nil {
-    return
-  }
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  bucket := nitric.NewBucket("bucket-name").Allow(storage.BucketWrite, storage.BucketRead, storage.BucketDelete)
+
+  nitric.Run()
 }
 ```
 
@@ -64,9 +58,9 @@ This permission allows your function to delete files from the bucket
 See the following for examples on working with files in a bucket:
 
 - [On()](./bucket-on)
-- [File()](./bucket-file)
-- [File.Read()](./bucket-file-read)
-- [File.Write()](./bucket-file-write)
-- [File.Delete()](./bucket-file-delete)
-- [File.DownloadUrl()](./bucket-file-downloadurl)
-- [File.UploadUrl()](./bucket-file-uploadurl)
+- [Read()](./bucket-read)
+- [Write()](./bucket-write)
+- [Delete()](./bucket-delete)
+- [DownloadUrl()](./bucket-downloadurl)
+- [UploadUrl()](./bucket-uploadurl)
+- [ListFiles()](./bucket-listfiles)
diff --git a/src/pages/reference/go/topic/topic-publish.mdx b/src/pages/reference/go/topic/topic-publish.mdx
index e41331d57..e73031daa 100644
--- a/src/pages/reference/go/topic/topic-publish.mdx
+++ b/src/pages/reference/go/topic/topic-publish.mdx
@@ -8,29 +8,21 @@ Publish an event (push based message) to a topic.
 ```go
 import (
   "context"
-  "fmt"
 
-  "github.com/nitrictech/go-sdk/api/events"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-  updates, err := nitric.NewTopic("updates").Allow(nitric.TopicPublishing)
-  if err != nil {
-    fmt.Println(err)
+  updates := nitric.NewTopic("updates").Allow(topics.TopicPublish)
 
-    return
-  }
-
-  updates.Publish(context.TODO(), &events.Event{
-    Payload: map[string]interface{}{
+  updates.Publish(context.TODO(),
+    map[string]interface{}{
       "something": "amazing happened",
     },
-  })
+  )
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -40,19 +32,8 @@ func main() {
   <Property name="ctx" required type="context">
     The context of the call, used for tracing.
   </Property>
-  <Property name="event" required type="Event">
+  <Property name="event" required type="map[string]interface{}">
     The event to publish to the topic.
-    <Properties nested>
-      <Property name="ID" type="string">
-        Unique ID to apply to the event.
-      </Property>
-      <Property name="Payload" required type="map[string]interface{}">
-        Payload to send with the event.
-      </Property>
-      <Property name="PayloadType" type="string">
-        A hint to the type of payload supplied.
-      </Property>
-    </Properties>
   </Property>
   <Property name="opts" type="PublishOption">
     Optional function to send a message with a delay.
@@ -68,28 +49,21 @@ Publishing messages to a topic will push a copy of the message to each of the to
 ```go
 import (
   "context"
-  "fmt"
 
-  "github.com/nitrictech/go-sdk/api/events"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-  updates, err := nitric.NewTopic("updates").Allow(nitric.TopicPublishing)
-  if err != nil {
-    fmt.Println(err)
-
-    return
-  }
+  updates := nitric.NewTopic("updates").Allow(topics.TopicPublish)
 
-  err := updates.Publish(context.TODO(), &events.Event{
-    Payload: map[string]interface{}{
+  updates.Publish(context.TODO(),
+    map[string]interface{}{
       "something": "amazing happened",
     },
-  })
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  )
+
+  nitric.Run()
 }
 ```
 
@@ -100,34 +74,19 @@ You can delay the delivery of messages sent to a topic. The current maximum dela
 ```go
 import (
   "context"
-  "fmt"
   "time"
 
-  "github.com/nitrictech/go-sdk/api/events"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-  updates, err := nitric.NewTopic("updates").Allow(nitric.TopicPublishing)
-  if err != nil {
-    fmt.Println(err)
-
-    return
-  }
+  updates := nitric.NewTopic("updates").Allow(topics.TopicPublish)
 
-  updates.Publish(context.TODO(), &events.Event{
-    Payload: map[string]interface{}{
-      "something": "amazing happened",
-    },
-  }, events.WithDelay(time.Hour))
+  updates.Publish(context.TODO(), map[string]interface{}{
+    "something": "amazing happened",
+  }, topics.WithDelay(time.Hour))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
-
-### Notes
-
-- If an id is not supplied with an event a UUID(v4) will be generated for you.
-- A function may subscribe to OR publish to a topic but not both.
diff --git a/src/pages/reference/go/topic/topic-subscribe.mdx b/src/pages/reference/go/topic/topic-subscribe.mdx
index d910ba569..7cd76565b 100644
--- a/src/pages/reference/go/topic/topic-subscribe.mdx
+++ b/src/pages/reference/go/topic/topic-subscribe.mdx
@@ -9,28 +9,23 @@ Subscribe a handler to a topic and receive new events for processing.
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  nitric.NewTopic("updates").Subscribe(func(ctx *handler.MessageContext, _ handler.MessageHandler) (*handler.MessageContext, error) {
+  nitric.NewTopic("updates").Subscribe(func() {
     fmt.Println("received update")
-
-    return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
 ## Parameters
 
 <Properties>
-  <Property name="middleware" required type="EventMiddleware">
-    The middleware (code) to be triggered by the topic.
+  <Property name="handler" required type="interface{}">
+    The callback to be triggered when new messages are sent to the topic.
   </Property>
 </Properties>
 
@@ -42,51 +37,16 @@ func main() {
 import (
   "fmt"
 
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/topics"
 )
 
 func main() {
-  nitric.NewTopic("updates").Subscribe(func(ctx *handler.MessageContext, _ handler.MessageHandler) (*handler.MessageContext, error) {
-    fmt.Println("received update")
-
-    return ctx, nil
+  nitric.NewTopic("updates").Subscribe(func(ctx *topics.Ctx) {
+    fmt.Printf("received update %+v", ctx.Request.Message())
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
-}
-```
-
-### Subscribe to a topic with multiple middleware
-
-```go
-import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
-  "github.com/nitrictech/go-sdk/nitric"
-)
-
-func validateUpdate(ctx *handler.MessageContext, next handler.MessageHandler) (*handler.MessageContext, error) {
-  // validate update
-
-  return next(ctx)
-}
-
-func handleUpdate(ctx *handler.MessageContext, next handler.MessageHandler) (*handler.MessageContext, error) {
-  // handle update
-
-  return next(ctx)
-}
-
-func main() {
-  nitric.NewTopic("updates").Subscribe(handler.ComposeMessageMiddleware(validateUpdate, handleUpdate))
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/topic/topic.mdx b/src/pages/reference/go/topic/topic.mdx
index 7973296b4..468f7811c 100644
--- a/src/pages/reference/go/topic/topic.mdx
+++ b/src/pages/reference/go/topic/topic.mdx
@@ -7,17 +7,13 @@ Creates a new Topic.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
   updates := nitric.NewTopic("updates")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -35,17 +31,13 @@ func main() {
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
   updates := nitric.NewTopic("updates")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/api/api-delete.mdx b/src/pages/reference/go/v0/api/api-delete.mdx
index 0dc5e95d8..e5eb26c3f 100644
--- a/src/pages/reference/go/v0/api/api-delete.mdx
+++ b/src/pages/reference/go/v0/api/api-delete.mdx
@@ -29,9 +29,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +119,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -158,9 +154,7 @@ func main() {
 
   api.Delete("/hello/:name", faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -190,8 +184,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-details.mdx b/src/pages/reference/go/v0/api/api-details.mdx
index e7e8aa9c7..b92c8fe28 100644
--- a/src/pages/reference/go/v0/api/api-details.mdx
+++ b/src/pages/reference/go/v0/api/api-details.mdx
@@ -29,9 +29,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -68,8 +66,6 @@ func main() {
 
   fmt.Println(details.URL)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-get.mdx b/src/pages/reference/go/v0/api/api-get.mdx
index dae0c8121..5fa022b1f 100644
--- a/src/pages/reference/go/v0/api/api-get.mdx
+++ b/src/pages/reference/go/v0/api/api-get.mdx
@@ -29,9 +29,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +119,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -158,8 +154,6 @@ func main() {
 
   api.Get("/hello/:name", faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-patch.mdx b/src/pages/reference/go/v0/api/api-patch.mdx
index 59902a1a9..66236e2f8 100644
--- a/src/pages/reference/go/v0/api/api-patch.mdx
+++ b/src/pages/reference/go/v0/api/api-patch.mdx
@@ -29,9 +29,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +119,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -158,9 +154,7 @@ func main() {
 
   api.Patch("/hello/:name", faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -190,8 +184,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-post.mdx b/src/pages/reference/go/v0/api/api-post.mdx
index 515f69b04..8f2704d26 100644
--- a/src/pages/reference/go/v0/api/api-post.mdx
+++ b/src/pages/reference/go/v0/api/api-post.mdx
@@ -29,9 +29,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +119,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -158,9 +154,7 @@ func main() {
 
   api.Post("/hello/:name", faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -190,8 +184,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-put.mdx b/src/pages/reference/go/v0/api/api-put.mdx
index 2e1b63e2d..1e57e1651 100644
--- a/src/pages/reference/go/v0/api/api-put.mdx
+++ b/src/pages/reference/go/v0/api/api-put.mdx
@@ -29,9 +29,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +119,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -158,9 +154,7 @@ func main() {
 
   api.Put("/hello/:name", faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -190,8 +184,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-all.mdx b/src/pages/reference/go/v0/api/api-route-all.mdx
index e8c868c70..1db86ff0d 100644
--- a/src/pages/reference/go/v0/api/api-route-all.mdx
+++ b/src/pages/reference/go/v0/api/api-route-all.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -85,9 +83,7 @@ func main() {
      /* this handler won't work */
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -114,9 +110,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -151,9 +145,7 @@ func main() {
 
   customersRoute.All(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -183,8 +175,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-delete.mdx b/src/pages/reference/go/v0/api/api-route-delete.mdx
index 979e2425f..dcfdf9ce9 100644
--- a/src/pages/reference/go/v0/api/api-route-delete.mdx
+++ b/src/pages/reference/go/v0/api/api-route-delete.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -110,9 +108,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -147,9 +143,7 @@ func main() {
 
   api.NewRoute("/hello/:name").Delete(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -179,8 +173,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-get.mdx b/src/pages/reference/go/v0/api/api-route-get.mdx
index 67e89a9d3..5d1f4b337 100644
--- a/src/pages/reference/go/v0/api/api-route-get.mdx
+++ b/src/pages/reference/go/v0/api/api-route-get.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -110,9 +108,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -147,8 +143,6 @@ func main() {
 
   api.NewRoute("/hello/:name").Get(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-patch.mdx b/src/pages/reference/go/v0/api/api-route-patch.mdx
index 184fe9ae2..14b99c08e 100644
--- a/src/pages/reference/go/v0/api/api-route-patch.mdx
+++ b/src/pages/reference/go/v0/api/api-route-patch.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -110,9 +108,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -147,9 +143,7 @@ func main() {
 
   api.NewRoute("/hello/:name").Patch(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -179,8 +173,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-post.mdx b/src/pages/reference/go/v0/api/api-route-post.mdx
index a4ff5af76..53629f4ca 100644
--- a/src/pages/reference/go/v0/api/api-route-post.mdx
+++ b/src/pages/reference/go/v0/api/api-route-post.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -110,9 +108,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -147,9 +143,7 @@ func main() {
 
   api.NewRoute("/hello/:name").Post(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -179,8 +173,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route-put.mdx b/src/pages/reference/go/v0/api/api-route-put.mdx
index 397882340..39957f0ea 100644
--- a/src/pages/reference/go/v0/api/api-route-put.mdx
+++ b/src/pages/reference/go/v0/api/api-route-put.mdx
@@ -24,9 +24,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -110,9 +108,7 @@ func main() {
     return next(ctx)
   }, nitric.WithNoMethodSecurity())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -147,9 +143,7 @@ func main() {
 
   api.NewRoute("/hello/:name").Put(faas.ComposeHttpMiddleware(authMiddleware, handleRequest))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -179,8 +173,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api-route.mdx b/src/pages/reference/go/v0/api/api-route.mdx
index b2c34bb64..2bf78957c 100644
--- a/src/pages/reference/go/v0/api/api-route.mdx
+++ b/src/pages/reference/go/v0/api/api-route.mdx
@@ -21,9 +21,7 @@ func main() {
 
   route := api.NewRoute("/hello")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -65,9 +63,7 @@ func main() {
 
   route := api.NewRoute("/hello")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -94,9 +90,7 @@ func main() {
   // Define route with customerId param
   route := api.NewRoute("/customers/:customerId")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -123,8 +117,6 @@ func main() {
 
   route := api.NewRoute("/hello", authMiddleware)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/api/api.mdx b/src/pages/reference/go/v0/api/api.mdx
index e2071cb5a..1bc5614c9 100644
--- a/src/pages/reference/go/v0/api/api.mdx
+++ b/src/pages/reference/go/v0/api/api.mdx
@@ -18,9 +18,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -115,9 +113,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -142,9 +138,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -178,9 +172,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -214,8 +206,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/collection/collection-collection.mdx b/src/pages/reference/go/v0/collection/collection-collection.mdx
index c87e56a6d..a2d6fa5f8 100644
--- a/src/pages/reference/go/v0/collection/collection-collection.mdx
+++ b/src/pages/reference/go/v0/collection/collection-collection.mdx
@@ -20,9 +20,7 @@ func main() {
 
   enemies := profiles.Collection("enemies")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -55,9 +53,7 @@ func main() {
 
   enemiesQuery := enemies.Query()
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-doc-collection.mdx b/src/pages/reference/go/v0/collection/collection-doc-collection.mdx
index 071b01d5b..2fe65fad8 100644
--- a/src/pages/reference/go/v0/collection/collection-doc-collection.mdx
+++ b/src/pages/reference/go/v0/collection/collection-doc-collection.mdx
@@ -23,9 +23,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-doc-delete.mdx b/src/pages/reference/go/v0/collection/collection-doc-delete.mdx
index 15ca351e4..6a7d45181 100644
--- a/src/pages/reference/go/v0/collection/collection-doc-delete.mdx
+++ b/src/pages/reference/go/v0/collection/collection-doc-delete.mdx
@@ -26,9 +26,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-doc-get.mdx b/src/pages/reference/go/v0/collection/collection-doc-get.mdx
index 642d0d63a..ef5cbf0dd 100644
--- a/src/pages/reference/go/v0/collection/collection-doc-get.mdx
+++ b/src/pages/reference/go/v0/collection/collection-doc-get.mdx
@@ -28,9 +28,7 @@ func main() {
 
   fmt.Println(doc.Content())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-doc-set.mdx b/src/pages/reference/go/v0/collection/collection-doc-set.mdx
index bbfb062b2..eafb72a43 100644
--- a/src/pages/reference/go/v0/collection/collection-doc-set.mdx
+++ b/src/pages/reference/go/v0/collection/collection-doc-set.mdx
@@ -29,9 +29,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -74,9 +72,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -111,9 +107,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-doc.mdx b/src/pages/reference/go/v0/collection/collection-doc.mdx
index eafb3dd39..4897dac2e 100644
--- a/src/pages/reference/go/v0/collection/collection-doc.mdx
+++ b/src/pages/reference/go/v0/collection/collection-doc.mdx
@@ -20,9 +20,7 @@ func main() {
 
   drakeProfileRef := profiles.Doc("Drake Mallard")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-query-fetch.mdx b/src/pages/reference/go/v0/collection/collection-query-fetch.mdx
index 73e5c0f8f..8b82e57a7 100644
--- a/src/pages/reference/go/v0/collection/collection-query-fetch.mdx
+++ b/src/pages/reference/go/v0/collection/collection-query-fetch.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -61,9 +59,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -104,9 +100,7 @@ func main() {
     }
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-query-limit.mdx b/src/pages/reference/go/v0/collection/collection-query-limit.mdx
index d70881555..8b9d215e1 100644
--- a/src/pages/reference/go/v0/collection/collection-query-limit.mdx
+++ b/src/pages/reference/go/v0/collection/collection-query-limit.mdx
@@ -20,9 +20,7 @@ func main() {
 
   profilesQuery := profiles.Query().Limit(10)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-query-stream.mdx b/src/pages/reference/go/v0/collection/collection-query-stream.mdx
index 736234026..cce906da4 100644
--- a/src/pages/reference/go/v0/collection/collection-query-stream.mdx
+++ b/src/pages/reference/go/v0/collection/collection-query-stream.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -71,9 +69,7 @@ func main() {
     fmt.Println(res.Content())
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-query-where.mdx b/src/pages/reference/go/v0/collection/collection-query-where.mdx
index 6aa4b3988..f1be252de 100644
--- a/src/pages/reference/go/v0/collection/collection-query-where.mdx
+++ b/src/pages/reference/go/v0/collection/collection-query-where.mdx
@@ -23,9 +23,7 @@ func main() {
     documents.Condition("name").StartsWith(documents.StringValue("T")),
   )
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -63,9 +61,7 @@ func main() {
     documents.Condition("firstName").Eq(documents.StringValue("Drake")),
   )
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -90,9 +86,7 @@ func main() {
     documents.Condition("age").Gt(documents.DoubleValue(21)),
   )
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection-query.mdx b/src/pages/reference/go/v0/collection/collection-query.mdx
index dfda52e93..90d580561 100644
--- a/src/pages/reference/go/v0/collection/collection-query.mdx
+++ b/src/pages/reference/go/v0/collection/collection-query.mdx
@@ -20,9 +20,7 @@ func main() {
 
   profilesQuery := profiles.Query()
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/collection/collection.mdx b/src/pages/reference/go/v0/collection/collection.mdx
index 163915367..b73771184 100644
--- a/src/pages/reference/go/v0/collection/collection.mdx
+++ b/src/pages/reference/go/v0/collection/collection.mdx
@@ -18,9 +18,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -76,8 +74,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/queues/queue-receive.mdx b/src/pages/reference/go/v0/queues/queue-receive.mdx
index a1cc9c7df..52e342d8f 100644
--- a/src/pages/reference/go/v0/queues/queue-receive.mdx
+++ b/src/pages/reference/go/v0/queues/queue-receive.mdx
@@ -33,9 +33,7 @@ func main() {
     t.Complete(ctx)
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -107,8 +105,6 @@ func main() {
     t.Complete(ctx)
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/queues/queue-send.mdx b/src/pages/reference/go/v0/queues/queue-send.mdx
index c54c6e45c..9f671eec3 100644
--- a/src/pages/reference/go/v0/queues/queue-send.mdx
+++ b/src/pages/reference/go/v0/queues/queue-send.mdx
@@ -33,9 +33,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -82,9 +80,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/queues/queue.mdx b/src/pages/reference/go/v0/queues/queue.mdx
index e10f29c19..75d1f606c 100644
--- a/src/pages/reference/go/v0/queues/queue.mdx
+++ b/src/pages/reference/go/v0/queues/queue.mdx
@@ -19,9 +19,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -76,9 +74,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -100,9 +96,7 @@ func main() {
 
   tasks := queue.Receive(context.TODO(), 10)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/schedule/schedule-cron.mdx b/src/pages/reference/go/v0/schedule/schedule-cron.mdx
index 7060607c9..73247bd29 100644
--- a/src/pages/reference/go/v0/schedule/schedule-cron.mdx
+++ b/src/pages/reference/go/v0/schedule/schedule-cron.mdx
@@ -20,9 +20,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -66,9 +64,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -97,8 +93,6 @@ func sendNotification(ctx *faas.EventContext, next faas.EventHandler) (*faas.Eve
 func main() {
   nitric.NewSchedule("check for updates").Cron("0 1 1 * *", faas.ComposeEventMiddleware(generateReport, sendNotification))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/schedule/schedule-every.mdx b/src/pages/reference/go/v0/schedule/schedule-every.mdx
index c1df20c5d..0405a4141 100644
--- a/src/pages/reference/go/v0/schedule/schedule-every.mdx
+++ b/src/pages/reference/go/v0/schedule/schedule-every.mdx
@@ -21,9 +21,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -60,9 +58,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -91,8 +87,6 @@ func sendNotification(ctx *faas.EventContext, next faas.EventHandler) (*faas.Eve
 func main() {
   nitric.NewSchedule("aggregate data").Every("3 days", faas.ComposeEventMiddleware(generateReport, sendNotification))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/schedule/schedule.mdx b/src/pages/reference/go/v0/schedule/schedule.mdx
index 3183980d0..339c77b6e 100644
--- a/src/pages/reference/go/v0/schedule/schedule.mdx
+++ b/src/pages/reference/go/v0/schedule/schedule.mdx
@@ -20,9 +20,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -66,8 +64,6 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/secrets/secret-latest.mdx b/src/pages/reference/go/v0/secrets/secret-latest.mdx
index 8265e6f84..a4bd1203a 100644
--- a/src/pages/reference/go/v0/secrets/secret-latest.mdx
+++ b/src/pages/reference/go/v0/secrets/secret-latest.mdx
@@ -20,9 +20,7 @@ func main() {
 
   latest := secret.Latest()
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -51,9 +49,7 @@ func main() {
 
   latest := secret.Latest()
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -79,9 +75,7 @@ func main() {
 
   fmt.Println(value.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/secrets/secret-put.mdx b/src/pages/reference/go/v0/secrets/secret-put.mdx
index dc54a8af1..6df427cdc 100644
--- a/src/pages/reference/go/v0/secrets/secret-put.mdx
+++ b/src/pages/reference/go/v0/secrets/secret-put.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -68,9 +66,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -99,8 +95,6 @@ func main() {
 
   fmt.Println(versionRef.Version())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/secrets/secret-version-access.mdx b/src/pages/reference/go/v0/secrets/secret-version-access.mdx
index ad7286ed8..6068b4010 100644
--- a/src/pages/reference/go/v0/secrets/secret-version-access.mdx
+++ b/src/pages/reference/go/v0/secrets/secret-version-access.mdx
@@ -25,9 +25,7 @@ func main() {
 
   fmt.Println(value.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -63,9 +61,7 @@ func main() {
 
   fmt.Println(value.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -93,8 +89,6 @@ func main() {
 
   fmt.Println(version.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/secrets/secret-version.mdx b/src/pages/reference/go/v0/secrets/secret-version.mdx
index 6b5059d2d..a5d6fbd95 100644
--- a/src/pages/reference/go/v0/secrets/secret-version.mdx
+++ b/src/pages/reference/go/v0/secrets/secret-version.mdx
@@ -20,9 +20,7 @@ func main() {
 
   version := secret.Version("the-version-id")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -53,9 +51,7 @@ func main() {
 
   version := secret.Version("the-version-id")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -83,9 +79,7 @@ func main() {
 
   fmt.Println(version.AsString())
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/secrets/secret.mdx b/src/pages/reference/go/v0/secrets/secret.mdx
index 41f3d5029..3ba9a9585 100644
--- a/src/pages/reference/go/v0/secrets/secret.mdx
+++ b/src/pages/reference/go/v0/secrets/secret.mdx
@@ -18,9 +18,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -70,9 +68,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/storage/bucket-file-delete.mdx b/src/pages/reference/go/v0/storage/bucket-file-delete.mdx
index a593dfa45..d836c9452 100644
--- a/src/pages/reference/go/v0/storage/bucket-file-delete.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file-delete.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -61,8 +59,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/storage/bucket-file-downloadurl.mdx b/src/pages/reference/go/v0/storage/bucket-file-downloadurl.mdx
index 3776167c8..9e793c4df 100644
--- a/src/pages/reference/go/v0/storage/bucket-file-downloadurl.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file-downloadurl.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -64,9 +62,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -106,8 +102,6 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/storage/bucket-file-read.mdx b/src/pages/reference/go/v0/storage/bucket-file-read.mdx
index 8c4f81a07..091d6f3cd 100644
--- a/src/pages/reference/go/v0/storage/bucket-file-read.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file-read.mdx
@@ -26,9 +26,7 @@ func main() {
 
   fmt.Println(contents)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -65,8 +63,6 @@ func main() {
 
   fmt.Println(contents)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/storage/bucket-file-uploadurl.mdx b/src/pages/reference/go/v0/storage/bucket-file-uploadurl.mdx
index e983864c9..a8cda7b19 100644
--- a/src/pages/reference/go/v0/storage/bucket-file-uploadurl.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file-uploadurl.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -64,8 +62,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/storage/bucket-file-write.mdx b/src/pages/reference/go/v0/storage/bucket-file-write.mdx
index 320a6f828..b8a1598a0 100644
--- a/src/pages/reference/go/v0/storage/bucket-file-write.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file-write.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -64,8 +62,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/storage/bucket-file.mdx b/src/pages/reference/go/v0/storage/bucket-file.mdx
index 997461e4d..9dcc1d09d 100644
--- a/src/pages/reference/go/v0/storage/bucket-file.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-file.mdx
@@ -20,9 +20,7 @@ func main() {
 
   file := bucket.File("cat.png")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/storage/bucket-files.mdx b/src/pages/reference/go/v0/storage/bucket-files.mdx
index 6806f1535..d05b556b5 100644
--- a/src/pages/reference/go/v0/storage/bucket-files.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-files.mdx
@@ -24,9 +24,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -68,9 +66,7 @@ func main() {
     file.Delete(ctx)
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/storage/bucket-on.mdx b/src/pages/reference/go/v0/storage/bucket-on.mdx
index 168c067d6..4bdb25ab2 100644
--- a/src/pages/reference/go/v0/storage/bucket-on.mdx
+++ b/src/pages/reference/go/v0/storage/bucket-on.mdx
@@ -45,9 +45,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/storage/bucket.mdx b/src/pages/reference/go/v0/storage/bucket.mdx
index d0a121503..27f3d1390 100644
--- a/src/pages/reference/go/v0/storage/bucket.mdx
+++ b/src/pages/reference/go/v0/storage/bucket.mdx
@@ -18,9 +18,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/topic/topic-publish.mdx b/src/pages/reference/go/v0/topic/topic-publish.mdx
index d5a8d9dc4..dd93c0682 100644
--- a/src/pages/reference/go/v0/topic/topic-publish.mdx
+++ b/src/pages/reference/go/v0/topic/topic-publish.mdx
@@ -28,9 +28,7 @@ func main() {
     },
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -87,9 +85,7 @@ func main() {
       "something": "amazing happened",
     },
   })
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -121,9 +117,7 @@ func main() {
     },
   }, events.WithDelay(time.Hour))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/topic/topic-subscribe.mdx b/src/pages/reference/go/v0/topic/topic-subscribe.mdx
index 21167d98c..484178f6c 100644
--- a/src/pages/reference/go/v0/topic/topic-subscribe.mdx
+++ b/src/pages/reference/go/v0/topic/topic-subscribe.mdx
@@ -20,9 +20,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -53,9 +51,7 @@ func main() {
     return ctx, nil
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -84,9 +80,7 @@ func handleUpdate(ctx *faas.EventContext, next faas.EventHandler) (*faas.EventCo
 func main() {
   nitric.NewTopic("updates").Subscribe(faas.ComposeEventMiddleware(validateUpdate, handleUpdate))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/topic/topic.mdx b/src/pages/reference/go/v0/topic/topic.mdx
index f1ac862cb..4d9736d31 100644
--- a/src/pages/reference/go/v0/topic/topic.mdx
+++ b/src/pages/reference/go/v0/topic/topic.mdx
@@ -15,9 +15,7 @@ import (
 func main() {
   updates := nitric.NewTopic("updates")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -43,9 +41,7 @@ import (
 func main() {
   updates := nitric.NewTopic("updates")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/reference/go/v0/websocket/websocket-close.mdx b/src/pages/reference/go/v0/websocket/websocket-close.mdx
index e4ea89761..a81ac9b9d 100644
--- a/src/pages/reference/go/v0/websocket/websocket-close.mdx
+++ b/src/pages/reference/go/v0/websocket/websocket-close.mdx
@@ -21,9 +21,7 @@ func main() {
 
   ws.Close(context.TODO(), "D28BA458-BFF4-404A")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -67,8 +65,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/websocket/websocket-details.mdx b/src/pages/reference/go/v0/websocket/websocket-details.mdx
index d171e8e33..aae1ad761 100644
--- a/src/pages/reference/go/v0/websocket/websocket-details.mdx
+++ b/src/pages/reference/go/v0/websocket/websocket-details.mdx
@@ -29,9 +29,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -68,8 +66,6 @@ func main() {
 
   fmt.Println(details.URL)
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/websocket/websocket-on.mdx b/src/pages/reference/go/v0/websocket/websocket-on.mdx
index 42954e474..b5c777f9c 100644
--- a/src/pages/reference/go/v0/websocket/websocket-on.mdx
+++ b/src/pages/reference/go/v0/websocket/websocket-on.mdx
@@ -34,9 +34,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -113,9 +111,7 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -151,8 +147,6 @@ func main() {
 
   ws.On(faas.WebsocketMessage, faas.ComposeWebsocketMiddleware(validateMessage, handleMessage))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/websocket/websocket-send.mdx b/src/pages/reference/go/v0/websocket/websocket-send.mdx
index 59d2cb516..fc856a648 100644
--- a/src/pages/reference/go/v0/websocket/websocket-send.mdx
+++ b/src/pages/reference/go/v0/websocket/websocket-send.mdx
@@ -21,9 +21,7 @@ func main() {
 
   ws.Send(context.TODO(), "D28BA458-BFF4-404A", []byte("Hello World"))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -118,8 +116,6 @@ func main() {
     return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/v0/websocket/websocket.mdx b/src/pages/reference/go/v0/websocket/websocket.mdx
index aace353b7..f373a3017 100644
--- a/src/pages/reference/go/v0/websocket/websocket.mdx
+++ b/src/pages/reference/go/v0/websocket/websocket.mdx
@@ -18,9 +18,7 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -50,8 +48,6 @@ func main() {
     return
   }
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/websocket/websocket-close.mdx b/src/pages/reference/go/websocket/websocket-close.mdx
index 81db2b838..faf0f3add 100644
--- a/src/pages/reference/go/websocket/websocket-close.mdx
+++ b/src/pages/reference/go/websocket/websocket-close.mdx
@@ -8,22 +8,16 @@ Closes a connection to a websocket
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  ws, err := nitric.NewWebsocket("public")
-  if err != nil {
-    return
-  }
+  ws := nitric.NewWebsocket("public")
 
   ws.Close(context.TODO(), "D28BA458-BFF4-404A")
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -44,31 +38,25 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	ws, err := nitric.NewWebsocket("public")
-	if err != nil {
-		return
-	}
-
-	// Broadcast message to all the registered websocket connections
-	ws.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		if ctx.Request.Message() == "close" {
-			err := ws.Close(context.Background(), ctx.Request.ConnectionID())
-			return ctx, err
-		}
-
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  ws := nitric.NewWebsocket("public")
+
+  // Broadcast message to all the registered websocket connections
+  ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) error {
+    if ctx.Request.Message() == "close" {
+      err := ws.Close(context.Background(), ctx.Request.ConnectionID())
+      return err
+    }
+
+    return nil
+  })
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/websocket/websocket-on.mdx b/src/pages/reference/go/websocket/websocket-on.mdx
index 4536ae57c..a6660e5ca 100644
--- a/src/pages/reference/go/websocket/websocket-on.mdx
+++ b/src/pages/reference/go/websocket/websocket-on.mdx
@@ -7,36 +7,26 @@ Register a handler for connections, disconnections, or messages for the websocke
 
 ```go
 import (
-  "fmt"
-
-  "github.com/nitrictech/go-sdk/handler"
   "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-  ws, err := nitric.NewWebsocket("public")
-  if err != nil {
-    return
-  }
+  ws := nitric.NewWebsocket("public")
 
-  ws.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
+  ws.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) {
     // handle connections
-    return next(ctx)
   })
 
-  ws.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
+  ws.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) {
     // handle disconnections
-    return next(ctx)
   })
 
-  ws.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
+  ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
     // handle messages
-    return next(ctx)
   })
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -44,13 +34,11 @@ func main() {
 
 <Properties>
   <Property name="eventType" required type="WebsocketEventType">
-    The type of websocket event to listen for. Can be `WebsocketConnect`,
-    `WebsocketDisconnect`, or `WebsocketMessage`.
+    The type of websocket event to listen for. Can be `EventType_Connect`,
+    `EventType_Disconnect`, or `EventType_Message`.
   </Property>
-  <Property name="middleware" required type="WebsocketMiddleware">
-    The middleware function to use as the handler for Websocket events. If you
-    want to compose more than one middleware use
-    `handler.ComposeWebsocketMiddleware`.
+  <Property name="handler" required type="interface{}">
+    The callback function to use as the handler for Websocket events.
   </Property>
 </Properties>
 
@@ -59,10 +47,8 @@ func main() {
 ### Register a handler for message events
 
 ```go
-ws.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
+ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
   fmt.Printf("New Message from %s: %s\n", ctx.Request.ConnectionID(), ctx.Request.Message())
-
-  return next(ctx)
 })
 ```
 
@@ -72,106 +58,52 @@ To store Websocket connections you can use a Nitric collection.
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	ws, err := nitric.NewWebsocket("public")
-	if err != nil {
-		return
-	}
-
-	connections, err := nitric.NewKv("connections").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
-
-	// Register a new connection on connect
-	ws.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		err := connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
-			"connectionId": ctx.Request.ConnectionID(),
-		})
-		if err != nil {
-			return ctx, err
-		}
-
-		return next(ctx)
-	})
-
-	// Remove a registered connection on disconnect
-	ws.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		err := connections.Delete(context.TODO(), ctx.Request.ConnectionID())
-		if err != nil {
-			return ctx, err
-		}
-
-		return next(ctx)
-	})
-
-	// Broadcast message to all the registered websocket connections
-	ws.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		connectionStream, err := connections.Keys(context.TODO())
-		if err != nil {
-			return ctx, err
-		}
-
-		for {
-			connectionId, err := connectionStream.Recv()
-			if err != nil {
-				break // reached the end of the documents
-			}
-
-			err = ws.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
-			if err != nil {
-				return ctx, err
-			}
-		}
-
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
-```
+  ws := nitric.NewWebsocket("public")
 
-### Chain functions as a single method handler
-
-```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
-)
+  connections := nitric.NewKv("connections").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
 
-func validateMessage(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-	// validate that the message does not contain explicit content
-
-	return next(ctx)
-}
-
-func handleMessage(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-	fmt.Printf("New Message from %s: %s\n", ctx.Request.ConnectionID(), ctx.Request.Message())
-
-	return next(ctx)
-}
+  // Register a new connection on connect
+  ws.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) error {
+    return connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
+      "connectionId": ctx.Request.ConnectionID(),
+    })
+  })
 
-func main() {
-	ws, err := nitric.NewWebsocket("public")
-	if err != nil {
-		return
-	}
+  // Remove a registered connection on disconnect
+  ws.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) error {
+    return connections.Delete(context.TODO(), ctx.Request.ConnectionID())
+  })
 
-	ws.On(handler.WebsocketMessage, handler.ComposeWebsocketMiddleware(validateMessage, handleMessage))
+  // Broadcast message to all the registered websocket connections
+  ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) error {
+    connectionStream, err := connections.Keys(context.TODO())
+    if err != nil {
+      return err
+    }
+
+    for {
+      connectionId, err := connectionStream.Recv()
+      if err != nil {
+        break // reached the end of the documents
+      }
+
+      err = ws.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
+      if err != nil {
+        return err
+      }
+    }
+
+    return nil
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
diff --git a/src/pages/reference/go/websocket/websocket-send.mdx b/src/pages/reference/go/websocket/websocket-send.mdx
index d6dd53e84..1cc34b957 100644
--- a/src/pages/reference/go/websocket/websocket-send.mdx
+++ b/src/pages/reference/go/websocket/websocket-send.mdx
@@ -8,22 +8,16 @@ Send a message from the websocket to a connection.
 ```go
 import (
   "context"
-  "fmt"
 
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  ws, err := nitric.NewWebsocket("public")
-  if err != nil {
-    return
-  }
+  ws := nitric.NewWebsocket("public")
 
   ws.Send(context.TODO(), "D28BA458-BFF4-404A", []byte("Hello World"))
 
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  nitric.Run()
 }
 ```
 
@@ -52,71 +46,51 @@ func main() {
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	ws, err := nitric.NewWebsocket("public")
-	if err != nil {
-		return
-	}
-
-	connections, err := nitric.NewKv("connections").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-	if err != nil {
-		return
-	}
-
-	// Register a new connection on connect
-	ws.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		err := connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
-			"connectionId": ctx.Request.ConnectionID(),
-		})
-		if err != nil {
-			return ctx, err
-		}
-
-		return next(ctx)
-	})
-
-	// Remove a registered connection on disconnect
-	ws.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		err := connections.Delete(context.TODO(), ctx.Request.ConnectionID())
-		if err != nil {
-			return ctx, err
-		}
-
-		return next(ctx)
-	})
-
-	// Broadcast message to all the registered websocket connections
-	ws.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		connectionStream, err := connections.Keys(context.TODO())
-		if err != nil {
-			return ctx, err
-		}
-
-		for {
-			connectionId, err := connectionStream.Recv()
-			if err != nil {
-				break // reached the end of the documents
-			}
-
-			err = ws.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
-			if err != nil {
-				return ctx, err
-			}
-		}
-
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  ws := nitric.NewWebsocket("public")
+  connections := nitric.NewKv("connections").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  // Register a new connection on connect
+  ws.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) error {
+    return connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
+      "connectionId": ctx.Request.ConnectionID(),
+    })
+  })
+
+  // Remove a registered connection on disconnect
+  ws.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) error {
+    return connections.Delete(context.TODO(), ctx.Request.ConnectionID())
+  })
+
+  // Broadcast message to all the registered websocket connections
+  ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) error {
+    connectionStream, err := connections.Keys(context.TODO())
+    if err != nil {
+      return err
+    }
+
+    for {
+      connectionId, err := connectionStream.Recv()
+      if err != nil {
+        break // reached the end of the documents
+      }
+
+      err = ws.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
+      if err != nil {
+        return err
+      }
+    }
+
+    return nil
+  })
+
+  nitric.Run()
 }
-
 ```
diff --git a/src/pages/reference/go/websocket/websocket.mdx b/src/pages/reference/go/websocket/websocket.mdx
index c262c9a9e..22a65a547 100644
--- a/src/pages/reference/go/websocket/websocket.mdx
+++ b/src/pages/reference/go/websocket/websocket.mdx
@@ -7,20 +7,13 @@ Creates a new Websocket.
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  ws, err := nitric.NewWebsocket("public")
-  if err != nil {
-    return
-  }
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  ws := nitric.NewWebsocket("public")
+
+  nitric.Run()
 }
 ```
 
@@ -39,19 +32,12 @@ func main() {
 
 ```go
 import (
-  "fmt"
-
   "github.com/nitrictech/go-sdk/nitric"
 )
 
 func main() {
-  ws, err := nitric.NewWebsocket("public")
-  if err != nil {
-    return
-  }
-
-  if err := nitric.Run(); err != nil {
-    fmt.Println(err)
-  }
+  ws := nitric.NewWebsocket("public")
+
+  nitric.Run()
 }
 ```
diff --git a/src/pages/schedules.mdx b/src/pages/schedules.mdx
index ba1d168f5..eaef6afcb 100644
--- a/src/pages/schedules.mdx
+++ b/src/pages/schedules.mdx
@@ -66,28 +66,24 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-	"time"
+  "fmt"
+  "time"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/schedules"
 )
 
 func main() {
-	// Run every 5 minutes
-	nitric.NewSchedule("process-transactions").Every("5 minutues", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
-		return ctx, nil
-	})
-	// Run at 22:00 Monday through Friday.
-	nitric.NewSchedule("send-reminder").Cron("0 22 * * 1-5", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Printf("reminder  at %s\n", time.Now().Format(time.RFC3339))
-		return ctx, nil
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // Run every 5 minutes
+  nitric.NewSchedule("process-transactions").Every("5 minutues", func(ctx *schedules.Ctx) {
+    fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
+  })
+  // Run at 22:00 Monday through Friday.
+  nitric.NewSchedule("send-reminder").Cron("0 22 * * 1-5", func(ctx *schedules.Ctx) {
+    fmt.Printf("reminder  at %s\n", time.Now().Format(time.RFC3339))
+  })
+
+  nitric.Run()
 }
 ```
 
@@ -156,35 +152,30 @@ async def process_rarely(ctx):
 
 ```go
 import (
-	"fmt"
-	"time"
+  "fmt"
+  "time"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/schedules"
 )
 
 func main() {
-	// Run every 5 minutes
-	nitric.NewSchedule("process-often").Every("5 minutes", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
-		return ctx, nil
-	})
-
-	// Run every 2 hours
-	nitric.NewSchedule("process-sometimes").Every("2 hours", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
-		return ctx, nil
-	})
-
-	// Run every 30 days
-	nitric.NewSchedule("process-rarely").Every("30 days", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
-		return ctx, nil
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // Run every 5 minutes
+  nitric.NewSchedule("process-often").Every("5 minutes", func(ctx *schedules.Ctx) {
+    fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
+  })
+
+  // Run every 2 hours
+  nitric.NewSchedule("process-sometimes").Every("2 hours", func(ctx *schedules.Ctx) {
+    fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
+  })
+
+  // Run every 30 days
+  nitric.NewSchedule("process-rarely").Every("30 days", func(ctx *schedules.Ctx) {
+    fmt.Printf("processing at %s\n", time.Now().Format(time.RFC3339))
+  })
+
+  nitric.Run()
 }
 ```
 
@@ -260,28 +251,24 @@ async def clear_data(ctx):
 package main
 
 import (
-	"fmt"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/schedules"
 )
 
 func main() {
-	// every 15 minutes
-	nitric.NewSchedule("check-for-updates").Cron("0/15 * * * *", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Println("checking for updates")
-		return ctx, nil
-	})
-
-	// at 1:00am on the 1st of every month
-	nitric.NewSchedule("delete-stale-data").Cron("0 1 1 * *", func(ctx *handler.IntervalContext, next handler.IntervalHandler) (*handler.IntervalContext, error) {
-		fmt.Println("clearing data")
-		return ctx, nil
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  // every 15 minutes
+  nitric.NewSchedule("check-for-updates").Cron("0/15 * * * *", func(ctx *schedules.Ctx) {
+    fmt.Println("checking for updates")
+  })
+
+  // at 1:00am on the 1st of every month
+  nitric.NewSchedule("delete-stale-data").Cron("0 1 1 * *", func(ctx *schedules.Ctx) {
+    fmt.Println("clearing data")
+  })
+
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/secrets.mdx b/src/pages/secrets.mdx
index e8490ed37..067984522 100644
--- a/src/pages/secrets.mdx
+++ b/src/pages/secrets.mdx
@@ -62,17 +62,14 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-	apiKey, _ := nitric.NewSecret("api-key").Allow(nitric.SecretPut, nitric.SecretAccess)
+  apiKey := nitric.NewSecret("api-key").Allow(secrets.SecretPut, secrets.SecretAccess)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -121,23 +118,19 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-	apiKey, _ := nitric.NewSecret("api-key").Allow(nitric.SecretPut)
-
-	latest, _ := apiKey.Put(context.TODO(), []byte("a new secret value"))
+  apiKey := nitric.NewSecret("api-key").Allow(secrets.SecretPut)
 
-	// We can get the version ID of our newly stored value
-	latest.Version()
+  // We can get the version ID of our newly stored value
+  versionId, _ := apiKey.Put(context.TODO(), []byte("a new secret value"))
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -185,11 +178,8 @@ version = api_key.version("7F5F86D0-D97F-487F")
 ```
 
 ```go
-// Get a reference to the latest version
-latest := apiKey.Latest()
-
-// Get a reference to a specific version
-version := apiKey.Version("7F5F86D0-D97F-487F")
+// golang does not have a SecretVersion object use the Secret.Access() and Secret.AccessVersion() methods
+// available on the secret
 ```
 
 ```dart
@@ -241,24 +231,27 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/secrets"
 )
 
 func main() {
-	apiKey, _ := nitric.NewSecret("api-key").Allow(nitric.SecretAccess)
+  apiKey := nitric.NewSecret("api-key").Allow(secrets.SecretAccess)
+
+  // Access the details of the latest version of a secret
+  latest, _ := apiKey.Access(context.TODO())
+
+  // Retrieve the value of the secret as a string
+  value := latest.AsString()
 
-	// Access the details of the latest version of a secret
-	latest, _ := apiKey.Latest().Access(context.TODO())
+  // Access the details of the latest version of a secret
+  someVersion, _ := apiKey.AccessVersion(context.TODO(), "known-version-id")
 
-	// Retrieve the value of the secret as a string
-	value := latest.AsString()
+  otherValue := someVersion.AsString()
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/sql.mdx b/src/pages/sql.mdx
index bbaca93c2..1cdd2fa2e 100644
--- a/src/pages/sql.mdx
+++ b/src/pages/sql.mdx
@@ -60,6 +60,18 @@ import 'package:nitric_sdk/nitric.dart';
 final db = Nitric.sql("my-database");
 ```
 
+```go
+import (
+  "github.com/nitrictech/go-sdk/nitric"
+)
+
+func main() {
+  db := nitric.NewSqlDatabase("my-database")
+
+  nitric.Run()
+}
+```
+
 </CodeGroup>
 
 ## Accessing a SQL database
@@ -124,6 +136,24 @@ Nitric.api("example").get("/hello", (ctx) async {
 });
 ```
 
+```go
+import (
+  "context"
+
+  "github.com/nitrictech/go-sdk/nitric"
+)
+
+func main() {
+  db := nitric.NewSqlDatabase("my-database")
+
+  nitric.NewApi("example").Get("/hello", func() {
+    connStr, _ := db.ConnectionString(context.TODO())
+  })
+
+  nitric.Run()
+}
+```
+
 </CodeGroup>
 
 ## Schemas and Migrations
@@ -199,6 +229,19 @@ final db = Nitric.sql("my-database",
 );
 ```
 
+```go
+import (
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/sql"
+)
+
+func main() {
+  db := nitric.NewSqlDatabase("my-database", sql.WithMigrationsPath("file://migrations/my-database"))
+
+  nitric.Run()
+}
+```
+
 </CodeGroup>
 
 When new migration files are added Nitric will automatically apply them when you redeploy your project.
@@ -239,6 +282,19 @@ final db = Nitric.sql("my-database",
 );
 ```
 
+```go
+import (
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/sql"
+)
+
+func main() {
+  db := nitric.NewSqlDatabase("my-database", sql.WithMigrationsPath("dockerfile://migrations.dockerfile"))
+
+  nitric.Run()
+}
+```
+
 </CodeGroup>
 
 <Note>
diff --git a/src/pages/storage.mdx b/src/pages/storage.mdx
index 95b970466..357facae1 100644
--- a/src/pages/storage.mdx
+++ b/src/pages/storage.mdx
@@ -55,17 +55,14 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketRead, nitric.BucketWrite, nitric.BucketDelete)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketRead, storage.BucketWrite, storage.BucketDelete)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -113,21 +110,7 @@ Nitric.run()
 ```
 
 ```go
-import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/nitric"
-)
-
-func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketRead, nitric.BucketWrite, nitric.BucketDelete)
-
-	profilePicture := profiles.File("users/bruce-wayne/profile.png")
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
-}
+// Go does not have File references use methods on the Bucket reference directly
 ```
 
 ```dart
@@ -176,24 +159,23 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketRead, nitric.BucketWrite, nitric.BucketDelete)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketRead, storage.BucketWrite, storage.BucketDelete)
 
-	files, _ := profiles.Files(context.TODO())
+  files, _ := profiles.ListFiles(context.TODO())
 
-	for _, file := range files {
-		fmt.Println(file.Name())
-	}
+  for _, file := range files {
+    fmt.Println(file)
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -245,20 +227,21 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketRead, nitric.BucketWrite, nitric.BucketDelete)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketRead, storage.BucketWrite, storage.BucketDelete)
 
-	image, _ := profiles.File("users/bruce-wayne/profile.png").Read(context.TODO())
+  image, err := profiles.Read(context.TODO(), "users/bruce-wayne/profile.png")
+  if err != nil {
+    // Handle error
+  }
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -310,22 +293,20 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketWrite)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketWrite)
 
-	profileImage := []byte("image data")
+  profileImage := []byte("image data")
 
-	_ = profiles.File("users/bruce-wayne/profile.png").Write(context.TODO(), profileImage)
+  _ = profiles.Write(context.TODO(), "users/bruce-wayne/profile.png", profileImage)
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -370,20 +351,18 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketDelete)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketDelete)
 
-	_ = profiles.File("users/bruce-wayne/profile.png").Delete(context.TODO())
+  _ = profiles.Delete(context.TODO(), "users/bruce-wayne/profile.png")
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -443,25 +422,23 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
-	"time"
+  "context"
+  "time"
 
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles, _ := nitric.NewBucket("profiles").Allow(nitric.BucketRead, nitric.BucketWrite)
+  profiles := nitric.NewBucket("profiles").Allow(storage.BucketRead, storage.BucketWrite)
 
-	// Expiry defaults to 600 (10 minutes)
-	downloadUrl, _ := profiles.File("profile.png").DownloadUrl(context.TODO(), time.Millisecond*3600)
+  // Expiry defaults to 600 (10 minutes)
+  downloadUrl, _ := profiles.DownloadUrl(context.TODO(), "profile.png", storage.WithPresignUrlExpiry(time.Millisecond*3600))
 
-	// Expiry defaults to 600 (10 minutes)
-	uploadUrl, _ := profiles.File("profile.png").UploadUrl(context.TODO(), time.Millisecond*3600)
+  // Expiry defaults to 600 (10 minutes)
+  uploadUrl, _ := profiles.UploadUrl(context.TODO(), "profile.png", storage.WithPresignUrlExpiry(time.Millisecond*3600))
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -525,24 +502,21 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles := nitric.NewBucket("profiles")
+  profiles := nitric.NewBucket("profiles")
 
-	// Filter for 'write' events for files starting with '/users/images'
-	profiles.On(handler.WriteNotification, "/users/images", func(ctx *handler.BlobEventContext, next handler.BlobEventHandler) (*handler.BlobEventContext, error) {
-		fmt.Printf("new profile image for %s was written", ctx.Request.Key())
-		return ctx, nil
-	})
+  // Filter for 'write' events for files starting with '/users/images'
+  profiles.On(storage.WriteNotification, "/users/images", func(ctx *storage.Ctx) {
+    fmt.Printf("new profile image for %s was written", ctx.Request.Key())
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -592,24 +566,21 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
+  "fmt"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/storage"
 )
 
 func main() {
-	profiles := nitric.NewBucket("profiles")
+  profiles := nitric.NewBucket("profiles")
 
-	// Filter for 'delete' events for any file
-	profiles.On(handler.DeleteNotification, "*", func(ctx *handler.BlobEventContext, next handler.BlobEventHandler) (*handler.BlobEventContext, error) {
-		fmt.Printf("%s was deleted", ctx.Request.Key())
-		return ctx, nil
-	})
+  // Filter for 'delete' events for any file
+  profiles.On(storage.DeleteNotification, "*", func(ctx *storage.Ctx) {
+    fmt.Printf("%s was deleted", ctx.Request.Key())
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
diff --git a/src/pages/websockets.mdx b/src/pages/websockets.mdx
index c041050dd..6341e8c75 100644
--- a/src/pages/websockets.mdx
+++ b/src/pages/websockets.mdx
@@ -57,33 +57,26 @@ Nitric.run()
 
 ```go
 import (
-	"fmt"
-
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	socket, _ := nitric.NewWebsocket("socket")
-
-	socket.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		// handle connections
-		return next(ctx)
-	})
-
-	socket.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		// handle disconnections
-		return next(ctx)
-	})
-
-	socket.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		// handle messages
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  socket := nitric.NewWebsocket("socket")
+
+  socket.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) {
+    // handle connections
+  })
+
+  socket.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) {
+    // handle disconnections
+  })
+
+  socket.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
+    // handle messages
+  })
+
+  nitric.Run()
 }
 ```
 
@@ -166,37 +159,31 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	socket, _ := nitric.NewWebsocket("socket")
-	connections, _ := nitric.NewKv("connections").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-
-	// Register a new connection on connect
-	socket.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		_ = connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
-			// Store any metadata related to the connection here
-			"connectionId": ctx.Request.ConnectionID(),
-		})
-
-		return next(ctx)
-	})
-
-	// Remove a registered connection on disconnect
-	socket.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		_ = connections.Delete(context.TODO(), ctx.Request.ConnectionID())
+  socket := nitric.NewWebsocket("socket")
+  connections := nitric.NewKv("connections").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  // Register a new connection on connect
+  socket.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) {
+    _ = connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
+      // Store any metadata related to the connection here
+      "connectionId": ctx.Request.ConnectionID(),
+    })
+  })
 
-		return next(ctx)
-	})
+  // Remove a registered connection on disconnect
+  socket.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) {
+    _ = connections.Delete(context.TODO(), ctx.Request.ConnectionID())
+  })
 
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  nitric.Run()
 }
 ```
 
@@ -310,54 +297,46 @@ Nitric.run()
 
 ```go
 import (
-	"context"
-	"fmt"
+  "context"
 
-	"github.com/nitrictech/go-sdk/handler"
-	"github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric"
+  "github.com/nitrictech/go-sdk/nitric/keyvalue"
+  "github.com/nitrictech/go-sdk/nitric/websockets"
 )
 
 func main() {
-	socket, _ := nitric.NewWebsocket("socket")
-	connections, _ := nitric.NewKv("connections").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
-
-	// Register a new connection on connect
-	socket.On(handler.WebsocketConnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		_ = connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
-			// Store any metadata related to the connection here
-			"connectionId": ctx.Request.ConnectionID(),
-		})
-
-		return next(ctx)
-	})
-
-	// Remove a registered connection on disconnect
-	socket.On(handler.WebsocketDisconnect, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		_ = connections.Delete(context.TODO(), ctx.Request.ConnectionID())
-
-		return next(ctx)
-	})
-
-	// Broadcast message to all the registered websocket connections
-	socket.On(handler.WebsocketMessage, func(ctx *handler.WebsocketContext, next handler.WebsocketHandler) (*handler.WebsocketContext, error) {
-		connectionStream, _ := connections.Keys(context.TODO())
-
-		for {
-			connectionId, err := connectionStream.Recv()
-			if err != nil {
-				break // reached the end of the documents
-			}
-
-			// Send a message to a connection
-			_ = socket.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
-		}
-
-		return next(ctx)
-	})
-
-	if err := nitric.Run(); err != nil {
-		fmt.Println(err)
-	}
+  socket := nitric.NewWebsocket("socket")
+  connections := nitric.NewKv("connections").Allow(keyvalue.KvStoreGet, keyvalue.KvStoreSet, keyvalue.KvStoreDelete)
+
+  // Register a new connection on connect
+  socket.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) {
+    _ = connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
+      // Store any metadata related to the connection here
+      "connectionId": ctx.Request.ConnectionID(),
+    })
+  })
+
+  // Remove a registered connection on disconnect
+  socket.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) {
+    _ = connections.Delete(context.TODO(), ctx.Request.ConnectionID())
+  })
+
+  // Broadcast message to all the registered websocket connections
+  socket.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
+    connectionStream, _ := connections.Keys(context.TODO())
+
+    for {
+      connectionId, err := connectionStream.Recv()
+      if err != nil {
+        break // reached the end of the documents
+      }
+
+      // Send a message to a connection
+      _ = socket.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
+    }
+  })
+
+  nitric.Run()
 }
 ```