How to Become a Golang Engineer (on the Back-End)

“Guys, I’ve got an idea. What if we could design a language that’s easy to read like Python, but fast? That has a slim feature-set like C, but is good for web development? That’s compiled like Java, but doesn’t need a VM?”

A dramatic pause.

“Fellas, what if we could create a language that would go on to be one of the best, easiest, quickest, most fun languages for back-end development ever?”

This is what I imagine Robert Griesemer, Rob Pike, or Ken Thompson saying to the others back on September 21, 2007 when Google was starting to think about designing a new language for their systems.

Flash-forward sixteen years and we’ve got Go, also called Golang, which in my humble opinion is one of the best languages full stop, especially for back-end development. Go is a statically-typed language with syntax roughly based on C, but with improvements and modifications like garbage collection, type safety, and concurrency.

If you’re coming to this article, you probably want to become a Golang back-end developer. No surprise. The entry-level salary for a Go developer is $117,000 a year, while the median is $135k a year. Not too shabby.

Or maybe you know Go already, and you’re wondering how to parlay that expertise into back-end development, which is a fantastic career path. Good news: Go, as I already spoiled, is awesome for back-end development.

In this article, I’ll break down the seven steps you need to become a Golang back-end developer.

Let’s jump in.

Why use Go? (Is Go a backend language?) 🔗

Actually, let’s take a brief pause. You may not yet be convinced that Go is, in fact, a backend language. Let’s take a minute to reiterate why and how it is. I’ve already written a comprehensive blog post on the subject of whether Go is a backend language, so I’ll just quote myself. There are three key reasons why Go is so great for the back end specifically:

• Go has built-in concurrency called “goroutines”. This means it can multitask, which is important for implementing high-performance servers and networked applications.
• Networking. Go has a robust standard library that offers support for plenty of common backend networking tasks, like HTTP handling and TLS (Transport Layer Security) encryption.
• Go goes fast. Go is famous for its rapid compilation times and efficient runtime performance, which is great for backend applications that need to handle a high volume of requests.

Also, it was literally built by Google for use in Google’s backend. It’s hard to get back-endier than that.

OK, now onto the seven steps, for real this time.

1. Learn the basics of Go 🔗

It should go without saying, but if you want a back-end job writing Go, you should know how Go works, generally.

If you already are familiar with Go, feel free to skip this section. You can also use it as a checklist to make sure you’re 100% on board with the language.

Syntax: Go is a statically-typed language with syntax similar to C. Go code is organized into packages, and each package can contain multiple functions.

Here is a quick quiz to determine if you’re familiar with Go syntax:

1. Which keyword is used to declare a new variable in Go?
2. What is the shorthand notation for declaring and assigning a new variable in Go?
3. How do you declare a constant in Go?
4. What keyword is used to define a new function in Go?
5. How do you define a struct in Go?

Concurrency: Go has built-in support for concurrency, making it easy to write programs that can execute multiple tasks simultaneously. The key to concurrency in Go is the use of goroutines, which are lightweight threads that are managed by the Go runtime.

Test your knowledge with this quick test:

1. What is a goroutine in Go?
2. How does Go manage concurrency?
3. What is a channel in Go?
4. Can multiple goroutines access the same variable at the same time?
5. Do you know how to synchronize access to shared resources in Go using mutexes?

Garbage collection: Go uses automatic memory management, which means that the Go runtime takes care of allocating and freeing memory. This allows Go developers to focus on writing code instead of managing memory.

Sure you’ve got the hang of it? Let’s find out:

1. How does Go handle memory allocation?
2. What is the purpose of the new keyword in Go?
3. What is a memory leak?
4. How does garbage collection affect program performance?

Types: Go has a strong type system that helps catch errors at compile time. The language provides several basic types, including integers, strings, and booleans, as well as more complex types like structs and interfaces.

1. What is a type system?
2. What are some of the basic types in Go?
3. What is a composite type in Go?
4. How does Go enforce type safety?
5. Can you define your own types in Go?

Interfaces: Go’s interface system allows developers to define contracts that specify how objects should behave. This makes it easy to write code that can work with many different types of objects.

1. What is an interface in Go?
2. What is the purpose of an interface?
3. Can a type implement multiple interfaces in Go?
4. How do you define an interface in Go?
5. What is the difference between an interface and a struct in Go?
6. How do generics work in Go?

Error handling: In Go, errors are values that can be returned from functions. This allows developers to handle errors in a structured way, making it easier to write robust and reliable code.

1. How are errors handled in Go?
2. What is the purpose of the panic keyword in Go?
3. Can you create your own error types in Go?
4. What is the difference between an error and an exception in Go?
5. What’s the best way to [add context to an existing error](/golang/wrapping-errors-in-go-how-to-handle-nested-errors/?

Testing: Go includes a built-in testing framework that makes it easy to write and run unit tests. This helps developers catch errors early and ensure that their code is working correctly.

1. What is a unit test in Go?
2. How does Go’s testing framework work?
3. What is the purpose of the testing.T type in Go?
4. Can you run multiple tests in a single Go file?
5. What is the difference between a unit test and an integration test in Go?

Tooling: Go comes with a rich set of command-line tools that help developers manage their projects. These tools include the go command, which can be used to build, test, and run Go programs, as well as tools for formatting, linting, and profiling code.

1. What is the go command in Go?
2. What is go fmt used for in Go?
3. How do you install a new Go package?
4. What is the purpose of go.mod in Go?
5. How do you run tests using the go command in Go?

Standard library: Go’s standard library provides a wide range of functionality, including support for networking, file I/O, cryptography, and much more. Many of these packages are designed to be easy to use and well-documented.

1. What types of functionality does the standard library provide in Go?
2. How do you import third-party libraries in Go?
3. What is the purpose of the io package in Go?
4. How do you use the net/http package in Go?

If you do find yourself struggling with any of these concepts, here are a few resources to help you out:

1. We’ve got a course for that. Our Go course (part of our Backend track) covers these topics in some depth, in around 20h of material paired with 179 challenges and quizzes.
2. StackOverflow. You can bet any of these questions have been posed on StackOverflow, and a generous Go developer has written a comprehensive, useful answer.
3. Go’s documentation. Google wants you to learn Go. They’ve put together some pretty great resources to teach you the basics.

Do I need to know any advanced Go topics specifically for back-end development? 🔗

The great thing about Go, unlike Python for example, is that it was built specifically for backend development.

These aren’t all the topics you should be an expert in, but just by learning the basics of Go, you’ve already learned most of what you need to know to use Go for back-end development.

2. Basics of back-end development 🔗

OK, now you know the basics of Go, it’s worth talking about the basics of back-end development. (We’ve got a blog post breaking down a typical back-end developer job description.)

Back-end dev doesn’t change much from language to language. For example, I previously wrote about Python for back-end development and there’s not a huge amount of daylight between what I’m about to tell you here. To be a Go back-end developer, here are the basic concepts you need to be familiar with.

Networking 🔗

Networking is how different computer systems and servers over a network are connected and exchange data.

You should be familiar with the most common networking protocols and standards, such as HTTP, HTTPS, TCP/IP, DNS, and SSL/TLS.

Full warning: Networking is a complex topic! Beware the trap of Go frameworks.

A lot of existing frameworks (think Django or Flask) are designed to help back-end developers around networking. But Go is the exception. There’s so much web tooling already in Go’s standard library that frameworks in Go often obscure how things work under the hood with little functionality benefit. (Here’s our position on backend frameworks if you want to learn more.)

Go’s standard library offers support for plenty of common backend networking tasks, like HTTP handling and TLS encryption.

API design 🔗

API design is the process of defining the interface and behavior of a software application or service that other applications can use to interact with it.

It’s similar but not the same as networking. APIs rely on network communication to receive and respond to requests from client applications, so you need to know how networking works to be able to design API requests and responses that get transmitted efficiently and securely.

Linux 🔗

Linux is one of the most popular operating systems for deploying backend systems and applications. You don’t need to know it, but it certainly doesn’t hurt.

As a Go developer, you may find yourself using Linux as your development environment. Many Linux-based command-line tools are used in backend development, such as Git for version control, Docker for containerization, and Nginx for web server configuration.

The front end 🔗

Go is not a front-end language. For that reason, especially if you already know how to use Go, it’s a smart idea to get to know the basic concepts of the front end. To be an effective back-end developer, knowing how the front-end works, at least from a high-level is helpful.

Here are the key concepts you should be familiar with. You don’t need to know these as well as what I mentioned in earlier sections, but have at least a passing familiarity with them.

• HTML and CSS: This will help you understand how front-end developers create the structure and style of web pages.

• Javascript: This will help you know how front-end developers add interactivity and functionality to web pages by querying… you guessed it, back-end APIs.

3. Look at job postings 🔗

OK, by now you’ve got a solid grasp of the core concepts of Go and back-end development. The next step to becoming a Go back-end developer is to look at back-end job postings that specifically mention Go.

This is going to help you understand the deeper, more complex topics that will crop up, especially in the field you’re interested in.

(And, side note, you’ll rarely find a pure back-end Go developer role – they’ll often say things like, “This role is primarily for a backend engineer, but the ideal candidate would have some experience or interest working full stack,” like this Go job opening does.)

As soon as you run into the mention of something you’re not super familiar with, add it to a list and find tutorials on it. For example, this opening mentions Kubernetes and Docker, two very popular back-end technologies. If this looks like a good job opp, you should ensure that you know how to build a Docker image for a Go application.

This kind of technology shifts with some regularity _ e.g., Spark and Hadoop used to be much more popular; they’re waning now _ so I recommend, whenever you’re coming across this article, that you do your research to see what’s current today.

4. Investigate and practice related skills and technologies 🔗

Maybe back-end development was once its own discipline. But in today’s developer-poor job market, many jobs expect you to not just be a back-end developer, but also have a hand in DevOps, cloud engineering, and data engineering, among other disciplines.

This job, for example, also wants 2+ years of experience in database design. This one wants you to have comprehensive knowledge of CI/CD solutions, which are typically in the DevOps field.

You can’t learn it all, but I recommend you dabble a bit in:

• Systems admin
• Database admin
• DevOps
• Cloud Engineering
• DevSecOps

And see which you like best. You won’t be able to be a perfect match for every single Go back-end developer role, but you’ll be a much stronger candidate in the fields that are the most fun for you.

Technologies to learn 🔗

You’ll also need to get familiar with some of the most popular technologies and tools used in back-end development. Here are a few to get you started.

Databases 🔗

• PostgreSQL
• SQLite
• MySQL
• MongoDB
• Redis
• Elasticsearch
• Firebase
• Cassandra
• RabbitMQ
• Kafka
• Google PubSub
• Docker
• Kubernetes
• AWS/GCP

You don’t need to be an expert on all of them, but at least try some of them, and figure out what they are from a high level. This online flashcard game might help.

Also, if you want to dive deeper into popular back-end technologies, check out our article on that.

5. Take on personal projects 🔗

By now, you’ve got a comprehensive list of technologies, tools, and areas you want or need to learn more about. You can read tutorials until you’re blue in the face, but the best way to learn is by doing.

Here are a few examples of personal projects you can take on to become a Go back-end developer.

• Develop a CLI tool. Get experience building a standalone app that can interact with APIs, databases, and other backend systems. For example, we’ve got a great project that walks you through how to build a Pokedex on the command line in Go.
• Rewrite an existing project in Go. This is a good place to start because you know what the end product is supposed to be already.
• Create a microservice architecture. This project will teach you how to build and deploy containerized Go applications, and manage them using Kubernetes. Here’s a good example.
• Build a chat application. Using Go and WebSockets, this project gives you experience handling real-time data, like chat messages and providing functionality for multiple users. It’s also good for practicing with the front end. This is a great project to showcase Go’s many strengths, such as concurrency and scalability.
• Develop a web scraper. Use a library like Colly or Goquery. This project will give you experience building a backend system that can scrape and parse data from websites, and store it in a database or file. It also gives you exposure to some third-party libraries. This tutorial uses both libraries.

Projects are an important way not only of becoming familiar and practicing with these skills and competencies but letting potential employers know you can do these things.

6. Get certified 🔗

Becoming certified is an important step on your journey to becoming a Go back-end developer.

Typically, you’ll get certified after learning a course. There are so many places to get certifications, and almost all those platforms offer Golang certifications. Here’s a selection:

• Boot.dev: We offer not just a course, projects for your portfolio, and a kickass blog, but also a certification that says you can do the things you say you can!
• Coursera. Coursera offers courses run by industry and education professionals. Courses range from as generic as “Getting Started with Go” to as specific as “Use Go Code to Work With Google Cloud Data Sources.”
• Udemy. This one carries less weight since anyone can upload and teach a Go course, but it’s still a good place to get certifications in more niche competencies, like “Building Modern Web Apps with Go” or comprehensive tracks like “Backend Master Class [Golang + Postgres + Kubernetes + gRPC]”

If I can be honest for a moment, Golang back-end developers are in high demand. You don’t need a degree. You don’t need a prestige certification. Employers will be excited to see you can do the things they need you to do.

7. Be confident, humble, and practiced 🔗

At this point, you’ve:

• Learned the basics of Go, if you didn’t already.
• Checked off the main competencies of any back-end developer
• Looked at enough job postings to get a sense of any edge-case skills or competencies you should learn.
• Investigated neighbor skills to back-end development, since more and more jobs expect you to be a unicorn that can do full-stack, systems administration, database design, and infosec to boot.
• Taken on personal projects to get your feet wet with the realities of back-end development in Go.
• Received certifications from an external source that prove you can do the thing.

The only thing remaining to become a Golang backend developer is to apply for jobs that look like a good fit for your skills and interests – and smash the interview.

To crush your interview, I recommend you practice common interview questions on platforms like StrataScratch or Glassdoor.

Research has also found that confidence and humility are the key traits to show off at interviews. (Lane, our founder, wrote about that here if you want to read more.)

Confidence matters because your employer wants to be sure that:

• They won’t have to hold your hand
• You will quickly be able to contribute
• You will take problems off their plate
• Hiring you makes them look good

Humility matters because people hire people they like, and know-it-alls are not fun to hang out with. You should demonstrate that:

• You’re enjoyable to work with
• You will be teachable and learn quickly
• You can adapt to however the team does things

How to become a Golang back-end developer in 7 steps 🔗

It’s easier than you might think, not least because back-end developers are in high demand, and Go is a language built specifically for the backend. That said, you need to be ready to put in some serious work and write a lot of code.

If you have:

• A solid portfolio
• Certificates that prove your competencies
• A humble yet confident attitude
• Good answers to interview questions

Then you’re well on your way to becoming a Go back-end developer. Hopefully, this roadmap helped you on your way to becoming a Go backend developer!