You've been coding for a while now and feel somewhat comfortable with it. But when it comes to using Git you still fumble around.

You know how to commit your code. Maybe you have worked with branches here and there. But for the most part, you've been working on the "master" branch on your own.

And to be honest, you've been fine.

At the same time, you know that you'll have to work with a team of developers eventually. You'll have to collaborate with other professionals on a common code-base.

So there's the question:

How do real dev teams in real companies use Git?

You know there should be best practices and workflows. But the tutorials you find are just too basic or abstract. How are you supposed to learn the Git workflows of the pros?

What if you could experience a professional Git workflow?

You read correctly. What if you could not only learn how to use Git in a team, in theory, but experience it hands-on? And what if you had the help of resources that go into depth and cover edge cases on top of that?

You could get your Git knowledge on par with your coding skills. And once you need it in real life you could navigate through the Git workflow with a clear head.

You'd be independent of the help of the senior devs.

At least a bit. But how can you get real experience in a Git workflow used by teams without the essential ingredient: a team?

That's what I created this interactive Git course for

Learn how to use Git in a team with a workflow that is used in many companies around the world: the GitHub flow.

Unlike other interactive Git tutorials you won't work inside the browser in a fake environment but rather in a real developer environment:

• on your machine inside your editor
• using the command line
• with a repository on GitHub
• with professional branch protection rules.

Don't worry, you don't need to know all of this already. You'll get resources and a roadmap so you can guide yourself through the process during the course. And in real life.

Now, where exactly does the team part come into play?

This is where it gets really interesting. You will have a bot teammate who helps you along the way. She will collaborate with you by reviewing your code, requesting changes, and implementing features.

You as well will have to review the code so you can see both sides of the table. You'll work on multiple branches at the same time and run into merge conflicts. Just like in a real team.

This way you will really experience what it feels like to work in a team of developers using a professional Git workflow.

This course is completely free

You don't have to pay and you don't need to subscribe to anything. I'd appreciate it if you could share this course with your friends though.

Also, if you're a React developer and enjoy this experience have a look at my other course. It has a similar approach but teaches many more professional skills by building a guided project based on designs and tasks. Just like a real-world project.

Note that this course doesn't cover the very basics of Git. You're expected to know at least a bit about commits and branches. More advanced topics like merging, squash merging, and rebasing are covered in the course material though.

Ready to learn how professional teams use Git?

Who am I?

Hi, I'm Johannes Kettmann, the creator of this course.

I'm a self-taught fullstack JS developer and know the struggle of learning how to work professionally with Git first-hand.

When I started to code I had no clue about version control. At first, everything was simple. I wrote tiny programs that fit into a single file. Once my files grew larger and larger and I started breaking existing code keeping track of previous versions seemed smart.

The perfect solution at the time was to create folders with names like "2010-04-23 15:23" to host the corresponding version of my code.

Didn't work out that well of course.

Finally, I realized there was an existing tool called Git that can help with versioned code. I was excited.

I happily committed to the master branch and pushed to my custom Git server. Better, but still not the smartest idea.

At some point, I landed my first professional job. And it was overwhelming. I had to understand the code base and figure out how to work with other developers. And last but not least, using Git in a team was totally different from what I was used to.

I wasn't allowed to commit to the sacred master branch anymore. Instead: Atomic commits, feature branches, releases, code reviews, merge, rebase...

It took me years to get fully used to that. And honestly, I'm still learning.

I hope that this course can help you to get up to speed much faster and in a safe environment. Maybe you don't have to experience the same stress and anxiety I had to go through back in the days.