Running Go on a Static Host: A Webhook Debugger With No Backend
I built a webhook signature debugger where the Go code runs in your browser. It is compiled to WebAssembly and served as plain static files from Brimble. No server, no container, no function. Your secret never leaves the tab.
Try it: https://brimble-guide.brimble.app/
Code: https://github.com/Luckyisrael/brimble-guide/tree/main/WASM%20Deployment%20article
This post has two parts. The first shows what is possible when you push real backend logic to the edge as static files. The second is my experience deploying it on Brimble, with what worked well and a few things I would be glad to help build.
Part 1: What is possible
The problem
Debugging a webhook usually means pasting a payload and a signing secret into some online tool and hoping it does not log them. That has always felt wrong.
EdgeHook Wasm does the check locally. Paste the payload, the secret and the signature header. You get PASS or FAIL, the computed signature next to the one you received, and the time it took.
It supports Paystack (HMAC-SHA512), Stripe (the t=...,v1=... format), GitHub (sha256= prefix), and generic SHA-256 or SHA-512 with hex or base64 output. It also pretty-prints JSON, lists top-level keys, and reports the exact line and column of a syntax error.
Why Go compiled to WebAssembly
- The standard library has everything needed:
crypto/hmac,crypto/sha256,crypto/sha512,crypto/subtle,encoding/json. Zero dependencies. - The core is a normal Go package with normal Go tests. I run
go testwithout a browser. - Static hosting plus Wasm means no cold starts and no server to secure. The code runs on the user's machine.
The shape of the project
Two sides. internal/verifier is pure Go and knows nothing about browsers. cmd/wasm is a thin layer that registers four functions on the browser's global object. The frontend is vanilla HTML, CSS and JavaScript. No npm, no framework.
The four functions are goVerifyWebhook, goInspectPayload, goGeneratePreset and goGetRuntimeInfo. Each returns one JSON string. The verify function takes five strings, the inspector and preset functions take one, and the runtime-info function takes none. I kept it that boring on purpose, because passing complex objects across the JavaScript and Wasm boundary gets messy fast. Each function also recovers from panics and returns an error field, so bad input never crashes the page.
Details that mattered
The raw body is sacred. An early version of my plan had a "pretty print" button that rewrote the payload. That silently breaks every signature, because signatures are computed over exact bytes. Formatted output now lives in a separate read-only box.
Presets are computed, not pasted. The sample buttons do not contain hardcoded signatures. Go computes them from a fixed test secret at runtime, and a unit test proves every preset verifies.
Honest timing. Browsers deliberately blur their timers, so one HMAC can read as 0 microseconds. Go runs the check 200 times and reports the average, and the UI says so.
Constant-time comparison. Signatures are compared with subtle.ConstantTimeCompare, the same code you would use on a real server.
Testing without a browser. I used the standard HMAC test vectors and cross-checked them with openssl. Then a small smoke test loads the real .wasm file and calls all four functions before I open a page. Coverage on the verifier package is 91.4%.
Numbers I measured locally
| Thing | Value |
|---|---|
| main.wasm size (raw) | 3,646,177 bytes (3.48 MB) |
| main.wasm size (transferred) | 1,081,392 bytes (1.03 MB) over the wire, gzip encoded |
| Wasm init time | 21 to 30 ms in headless Chrome on a local static server |
| Average verify time | Paystack 39.0 µs, Stripe 114.5 µs, GitHub 113.5 µs, each an average of 200 runs |
| Go version | go1.26.5 |
| Works offline | Yes, verified with headless Chrome offline network emulation |
A Go Wasm binary carries the Go runtime, so expect a few megabytes raw. Edge compression helps, and it is cached after the first load.
Part 2: Deploying on Brimble
What I did
First, sign up on brimble.io if you do not have an account.
On the Brimble dashboard, look towards the top right. You will see two bold buttons: a blue one and a grey one. The grey button is a powerful part of Brimble. It lets you create different environments, for example a production environment and a development environment, and Brimble handles the rest so you can focus on your code. I will talk about environments in a later article. For now, click the blue Create Project button.
The next page asks how you want to deploy. My personal favourite is connecting my GitHub account. You can also use GitLab, Bitbucket or a Docker image, depending on your setup. Follow the prompts, connect your account, and when the repository list appears, install only the repo you are working with. I do not give access to all my repositories. Once that is done, your account is authenticated with Brimble.
Why this is good: every commit you push to GitHub is deployed automatically to your environments, with no manual trigger. That also means you should always check that everything works locally before pushing, so you do not waste build minutes on a broken commit.
Which brings me to brimble.toml. A TOML file is just a small config file. TOML stands for Tom's Obvious, Minimal Language. It is plain text that a tool reads to know what to do, instead of you writing code for it. The rules are tiny: key = value pairs, [section] headers that group keys, and # for comments. We will not go too deep into TOML here, you can do a quick search if you want more. When you push to GitHub, Brimble looks for this file and uses it to work out how to build and publish your project. You can find ours at the root of the repo. It selects WASM Deployment article as the project root and dist as the output folder. The build command is a no-op echo prebuilt, because the dist folder is already built and committed. Keep it at the repository root. Brimble looks there first, and a copy inside a project folder will not be read.
When the repository is connected, Brimble greets you with a deployment page. Here you set the project name, branch, root directory, deployment type and build framework. Depending on the framework you choose, you may need to fill in build settings, but 99% of the time Brimble already has that covered. Just check that everything looks right, then click Deploy Project. For this project the deployment type is static site, and for the build framework I picked HTML.
Congratulations, you have successfully deployed a Go WebAssembly project on Brimble. You land on an overview page where you can see your infrastructure, how it is connected, whether it is running, the region it runs in, the framework, and your connected repository.
One tool you will need sooner or later is the logs. If something goes wrong, the deployment logs tell you what happened. If you work with AI, Brimble provides a button that copies the logs for you. Paste them into your agent and it can trace the problem, fix it and redeploy.
Steps, with screenshots:
- Click Create Project in the top right of the dashboard, then choose GitHub as the source.
- Connect GitHub and select only the repository you want to deploy.
- On the deployment page, choose static site and HTML, check the root and build settings, and click Deploy Project.
- Open the overview page and the deployment logs to confirm the site is live.
We will explore more of Brimble in later articles.
Keep these in mind
- Connecting GitHub was a short flow, and I could give Brimble access to just one repository instead of all of them.
- Every push deployed automatically, so there was no separate deploy step to remember.
- The deployment logs were easy to find, and the copy button made it simple to hand them to an AI agent.
Build your own
The pattern is simple and reusable:
- Keep your logic in a pure Go package with tests.
- Add a thin
syscall/jslayer that takes strings and returns JSON. - Compile with
GOOS=js GOARCH=wasm. - Ship the
.wasm,wasm_exec.jsand a few static files.
Anything that is CPU-bound and safe to run on the user's machine is a candidate: validators, formatters, parsers, converters, offline tools.
Try EdgeHook here: https://brimble-guide.brimble.app/. Paste a payload, paste a secret, and see if your signature really matches. If you deploy something with the same pattern, send it to me. I would like to see it.




Top comments (0)