You've successfully subscribed to Go Beyond
Great! Next, complete checkout for full access to Go Beyond
Welcome back! You've successfully signed in.
Success! Your account is fully activated, you now have access to all content.
Success! Your billing info is updated.
Billing info update failed.

Introducing WTF Dial (again)

A blog series where we build and deploy a real-world Go application.

Ben Johnson
Ben Johnson
Updating your WTF level in real-time at

A little history

Several years ago I started a collaborative, open-source project called WTF Dial to provide an example of how to build a real project in Go. The idea was to build a slice of the application every week and write a post about it.

Turns out that's a bad idea.

If there's one thing that I learned from that experience it's that I don't build applications in a linear fashion. I'll start on the database layer, jump to writing an HTML frontend, then circle back to implement some HTTP handling, and maybe throw in a CLI somewhere in there. Releasing the application in incremental, clean slices was never going to happen.

Since abandoning the project, I've had many requests to finish it. So I started over and built the entire application first. Now I'll write about it. You can find the application at and you can find the source code on GitHub.

Huge thanks to Cory LaNou from Gopher Guides for helping to review the project!

Ok, so WTF is WTF Dial?

It all started back in 2016 with a series of tweets from Peter Bourgon:

"I have an idea for a thing which helps with remote work, it is called The WTF Dial, let me explain. It is some analog knob or dial which you can dial to zero (No WTFs, all clear) or 100% (WTF?!)

The current state of the dial goes to some dashboard, along with all of your teammates. So at any moment you can see how fucked everyone is. Just as a passive indicator. If someone is WTF-ing, you can ask them if they want to chat, and help them get un-WTF'd."

Peter Bourgon

Essentially, it's a way to quantify and aggregate the feelings of your entire team into a single number. Sounds callous, sure, but it's just for fun.

Topics that we'll cover in this series

In this series, we'll start with architecture, move our way from the backend to the frontend, and also describe deployment strategies. We'll cover topics such as:

  • Application design & code structure
  • Working with SQL databases
  • HTTP & WebSockets
  • Using context.Context appropriately
  • Embedded file systems (introduced in Go 1.16)
  • Unit testing & end-to-end testing
  • Command line interfaces
  • CI/CD
  • Performance analysis & load testing

Have suggestions for topics you want covered or questions you want answered? Please check out the WTF Dial GitHub Discussions page to chat.

Why Go?

The Go programming language is known as a low-level language used for cloud infrastructure but I find it to be a fantastic language for general application development. It provides fast compile times for quick iteration that you'd expect from a language like Ruby but you also get basic type checking and performance like you'd find in a language like Java or C#.

The development experience with Go is great but it gets really good once you deploy. Applications are statically compiled so there is no runtime dependency or shared libraries to worry about. Just upload your binary and run it.

Go applications can have a small footprint as well so we can support hundreds of users with our application with even a small $5/month VPS. It's great for small applications like ours.

Follow along

If you're interested in this series, please sign up for the newsletter so you can get each new post in your inbox. Click here to subscribe for free.

WTF Dial

Ben Johnson

Freelance Go developer, author of BoltDB