Most Go courses teach the language first and leave the real work for later. This course does the opposite. From the first week, you build working software, and you learn each part of Go when your project needs it.

You build one project through the whole course: **Tasker**, a task manager.

**Part 1: Go through a command-line tool (Weeks 1–6)**
You start with a small program and grow it into a complete command-line tool. You learn types, structs, slices, maps, errors, pointers, interfaces, and packages by using them. You save data to JSON files, build commands and flags with Cobra, add structured logging with zap, and write tests. You finish this part by using goroutines and channels, then you release your tool as a binary that others can download.

**Part 2: Backend API (Weeks 7–14)**
You turn Tasker into a web service. You start with Go's standard `net/http` package to understand the basics, then build the API with Fiber. You organize the service into clear layers, store data in Postgres, manage the database schema with migrations, and generate type-safe queries with sqlc. You validate input, return consistent errors, and add authentication with JWT. You test the service with real databases using testcontainers. Then you add the patterns that production systems need: pagination, timeouts, background workers, rate limiting, metrics, and tracing.

**Part 3: Ship it (Weeks 15–16)**
You package the full system with Docker and Docker Compose and set up continuous integration with GitHub Actions. In the final project, your command-line tool becomes a client of your own API.

**Who this course is for**
- Beginners who want their first programming language to be practical and in demand
- Developers who know another language, such as Python, Java, JavaScript, or PHP, and want to build backend services and tools in Go

If you already program, you can move quickly through the first weeks. If you are new to programming, every lesson explains each step in plain language.

**What you will be able to do**
- Write clear, idiomatic Go code
- Build and release command-line tools with Cobra
- Design and build REST APIs with Fiber and Postgres
- Write unit and integration tests, including tests that use real databases
- Use concurrency safely with goroutines, channels, and context
- Add logging, metrics, and tracing to a service
- Package and deploy services with Docker and CI pipelines

**Tools and libraries you will use**
Go, Cobra, Viper, zap, Fiber, Postgres, pgx, sqlc, goose, testify, testcontainers-go, Docker, GoReleaser, golangci-lint, Prometheus, OpenTelemetry, and GitHub Actions. These are stable tools that many companies use in production today.

**How the course works**
The course is self-paced and takes about 16 weeks, with 3 to 4 lessons each week. Each lesson has a clear goal, a step-by-step build, an explanation of the Go concepts behind it, exercises, and a checkpoint. When you finish, you have a complete, tested, deployable project that you can show to employers.

A 16-week, project-based Go course. You build Tasker, first as a command-line tool and then as a backend API with Fiber and Postgres. You learn each part of the Go language at the moment your project needs it.

Learn Go by building a real command-line tool and a production-ready API, step by step.

Go for Backend and CLI Development

**You don't need to master Finnish grammar before you start speaking Finnish.**

Imagine walking into a café in Helsinki, ordering your coffee in Finnish, understanding the price, and responding confidently when the cashier asks you a question.

Or asking for directions, buying groceries, introducing yourself to a colleague, or arranging an appointment—without immediately switching to English.

That's what this course helps you work toward.

**Finnish for Everyday Life** is a practical, beginner-friendly course designed to take you from zero Finnish knowledge toward **CEFR A1 proficiency**, while helping you use what you learn in real situations from day one.

Instead of memorizing endless vocabulary lists or studying grammar in isolation, you'll learn Finnish through conversations and situations you're likely to encounter in Finland.

## What You'll Learn

By progressing through the course, you'll learn how to:

- **Start conversations:** Greet people, introduce yourself, ask basic questions, and respond naturally.
- **Shop and order food:** Buy groceries, understand prices, order at cafés, and ask for what you need.
- **Get around Finland:** Ask for directions, understand basic transport information, and navigate familiar places.
- **Talk about your life:** Describe your family, home, work, studies, daily routines, and interests.
- **Handle everyday situations:** Make simple appointments, explain basic needs, and ask for assistance.
- **Connect with people:** Make plans, accept invitations, and participate in short social conversations.
- **Understand spoken Finnish:** Recognize common expressions and become familiar with differences between standard and everyday spoken Finnish.
- **Build your A1 foundation:** Develop essential pronunciation, vocabulary, grammar, listening, reading, speaking, and writing skills.

## How You'll Learn

**Practical from the first lesson**

Every module focuses on a real-world situation. You'll learn useful Finnish expressions and practise applying them instead of waiting until you've studied all the grammar.

**Listen and learn**

Finnish examples and conversations include audio-supported learning, helping you become familiar with pronunciation, rhythm, and everyday expressions.

**Grammar that makes sense**

Learn the grammar behind the sentences you're using. Start with simple expressions and gradually develop the ability to construct your own sentences.

**Learn at your own pace**

Follow short, structured lessons, revisit unfamiliar concepts, and reinforce what you've learned through practical exercises and scenario-based reviews.

**A clear path toward A1**

The curriculum progressively develops the foundational skills associated with CEFR A1, so you're building language proficiency alongside everyday confidence.

## Course Structure

The course contains **12 practical modules and 72 lessons**, covering:

1. Your First Finnish Interactions
2. Buying Food and Groceries
3. Getting Around the City
4. Meeting People and Introducing Yourself
5. Family, Home and Personal Things
6. Daily Routines and Schedules
7. Places, Movement and Finding Things
8. Shopping and Solving Small Problems
9. Appointments, Health and Services
10. Work, Study and Everyday Messages
11. Friends, Weather and Plans
12. A1 Practical Finnish Challenge

## Who Is This Course For?

- Complete beginners with no previous Finnish knowledge.
- People planning to move to Finland or recently arrived.
- International students and professionals living in Finland.
- Anyone who wants to communicate in everyday Finnish rather than only memorize vocabulary.
- Learners looking for a structured, practical foundation before progressing to A2.

**No previous Finnish knowledge is required.** All explanations are in English, with Finnish examples and listening material throughout.

## Your Learning Goal

By the end of the course, you should be prepared to handle simple, familiar conversations, understand basic everyday information, and express yourself using essential Finnish vocabulary and sentence structures.

The course is designed to prepare you for CEFR A1-level communication. Your actual proficiency will depend on practice and demonstrated performance; course completion is not an official language certification.

**Start with your first Finnish conversation. Build the skills to use Finnish in your everyday life.**

Start using Finnish in everyday life from your very first lesson. Learn to order food, shop, travel, introduce yourself, ask for help, and handle real conversations through practical lessons, listening exercises, and essential grammar—progressively building your skills toward CEFR A1.

Finnish for Everyday Life: Beginner A1

Building an API is one thing.

Building a backend system that remains correct, reliable, observable, and maintainable as traffic grows, dependencies fail, data changes concurrently, and multiple engineering teams work on it is a very different challenge.

**Advanced Backend Engineering** is designed for backend developers who already understand application development and want to learn how production-grade backend systems are engineered.

Instead of focusing primarily on framework syntax, this course focuses on the engineering decisions behind reliable systems.

You will learn how to reason about architecture, service boundaries, databases, caching, asynchronous communication, distributed transactions, concurrency, failure recovery, performance, observability, and production operations.

Using **Java and Spring Boot** as the primary implementation stack, you will progressively design and build a distributed commerce platform containing services such as Orders, Inventory, Payments, Catalog, and Notifications.

Along the way, you will work with technologies and concepts including:

* Java and Spring Boot
* PostgreSQL
* Redis
* Kafka
* Debezium and Change Data Capture
* Temporal
* Docker
* Kubernetes
* OpenTelemetry
* Prometheus
* Grafana

But the goal of the course is not simply to teach these technologies.

The goal is to teach you **when to use them, why to use them, what problems they solve, and what new trade-offs they introduce**.

You will explore real production engineering problems such as duplicate requests, concurrent updates, database contention, stale caches, failed dependencies, message redelivery, partial transactions, consumer lag, cascading failures, unsafe schema migrations, and production incidents.

By the end of the course, you should be able to approach backend systems not simply as an application developer, but as an engineer capable of owning systems in production.

## What You Will Learn

By completing this course, you will learn how to:

* design backend architectures around real system requirements;
* identify appropriate service and domain boundaries;
* design APIs that remain safe under retries and concurrency;
* model relational data around access patterns;
* understand database transactions, isolation, locking, and contention;
* use caching effectively while managing consistency;
* build event-driven systems with Kafka;
* design idempotent producers and consumers;
* solve the database-and-message dual-write problem;
* implement transactional outbox and inbox patterns;
* use Change Data Capture with Debezium;
* design distributed transactions using sagas;
* understand orchestration and choreography;
* reason about race conditions and distributed coordination;
* implement retries, timeouts, circuit breakers, and backpressure;
* design systems for partial failure;
* build production observability using logs, metrics, and traces;
* define SLIs, SLOs, and error budgets;
* investigate latency and performance bottlenecks;
* estimate capacity and scale services;
* containerize and operate backend services with Kubernetes;
* perform safe database and API migrations;
* design zero-downtime deployment strategies;
* investigate and respond to production incidents;
* write technical RFCs and Architecture Decision Records;
* communicate architectural trade-offs clearly.

## Who This Course Is For

This course is designed for:

* backend developers who already know how to build REST APIs;
* Java and Spring Boot developers moving beyond CRUD applications;
* engineers preparing for senior backend engineering responsibilities;
* engineers working with distributed systems;
* developers who want stronger system design skills;
* engineers who want to understand production reliability and operations;
* experienced developers preparing for backend system-design interviews.

This is **not a beginner programming course**.

Learners should already be comfortable writing backend applications.

## Prerequisites

You should already understand:

* Java fundamentals;
* object-oriented programming;
* Spring Boot;
* REST APIs;
* HTTP fundamentals;
* relational databases;
* SQL;
* basic Git;
* basic Docker concepts.

Experience with PostgreSQL is recommended.

Kafka, Redis, Kubernetes, Temporal, Prometheus, and distributed systems knowledge are **not required**. They will be introduced as part of the course.

Go beyond building APIs and learn how production backend systems are actually designed and operated.

This advanced course covers distributed systems, data consistency, Kafka, caching, resilience, observability, SLOs, performance engineering, Kubernetes, safe deployments, and architectural decision-making using Java and Spring Boot.

Design, build, scale, and operate reliable production backend systems.

Advanced Backend Engineering

Learn Estonian from the ground up through practical situations you are likely to encounter while living, working, studying, or travelling in Estonia.

This course is designed for complete beginners and teaches Estonian through English. Instead of overwhelming you with grammar tables and all 14 Estonian cases at once, the course introduces vocabulary and grammar gradually through useful conversations and real-life situations.

You will begin with pronunciation, greetings, introductions, and simple sentence building. From there, you will learn how to talk about yourself and your family, understand numbers and time, shop for groceries, order food, navigate a city, use public transport, communicate at work, describe health problems, make appointments, and handle common everyday services.

Grammar is introduced when it becomes useful. You will learn the essential noun forms, common cases, verb conjugation, present and past tense, questions, location expressions, and other important patterns through examples you can immediately use.

Throughout the course, you will practice:

* Estonian pronunciation and sound length
* Everyday vocabulary and useful expressions
* Greetings and introductions
* Building natural Estonian sentences
* Essential noun forms and cases
* Common verbs and verb conjugation
* Numbers, dates, prices, and time
* Family and personal information
* Food, cafés, and restaurants
* Shopping and supermarkets
* Home and city vocabulary
* Directions and public transport
* Workplace conversations
* Healthcare and emergencies
* Weather and everyday small talk
* Talking about past events and future plans
* Common spoken Estonian
* Real-world dialogues and practical exercises

Rather than memorizing isolated vocabulary, you will learn words inside useful expressions and sentences. You will also gradually learn the important forms of Estonian words so that you can understand how the language actually works.

By the end of the course, you should be able to handle many basic everyday interactions in Estonian, understand common signs and expressions, introduce yourself, ask and answer simple questions, and participate in straightforward conversations when the other person speaks clearly.

The course aims to build a strong **CEFR A1 foundation with preparation for early A2**, giving you the skills and confidence needed to continue toward independent Estonian.

No previous knowledge of Estonian is required.

Start speaking and understanding practical Estonian from day one. Learn essential vocabulary, pronunciation, grammar, and everyday conversations through real-life situations such as shopping, cafés, public transport, work, healthcare, and daily life in Estonia.

Learn practical Estonian from English for everyday life, work, and living in Estonia.

Estonian for Everyday Life: Beginner A1

It’s time to move from the foundations of Java and Object-Oriented Programming into real-world backend development.

In this course, you won’t just learn Spring Boot features or annotations. You will build a production-style backend application from the ground up, step by step, and learn professional backend development through the process.

The course follows the workflow of a real engineering team—from understanding requirements and creating technical designs, RFCs, and engineering tickets to implementation, testing, code review, deployment, and investigating production issues.

Throughout the course, the same application will continue to evolve. Instead of learning each new concept through isolated examples, you will see where it fits in a real system, why it is needed, and how it is applied in practice.

The goal of this course is not simply to complete a backend project.

The goal is to build the foundation you need as a backend engineer to think about, design, build, and maintain production-quality software.

Build a production-style Java backend with Spring Boot while learning real-world engineering practices, from requirements and RFCs to testing, deployment, and production incidents.

Backend Development with Java & Spring Boot

## Learn Java with a Strong Engineering Foundation

Learning Java is not just about memorizing syntax or getting code to compile.

Strong software engineers learn how to break problems into smaller responsibilities, model software clearly, reason about trade-offs, and write code that remains understandable as applications grow.

**Java & Object-Oriented Programming Foundation** is designed to help you build that foundation from the beginning.

Across **11 modules and more than 100 lessons**, you will progress from Java fundamentals to object-oriented design, practical software modeling, refactoring, and increasingly realistic programming problems.

The goal is not only to teach you **what code to write**, but to help you understand **why a solution is designed that way**.

## Who Is This Course For?

This course is suitable for:

* Beginners starting their programming journey
* Developers moving to Java from another programming language
* Learners who want to strengthen their Java and OOP fundamentals
* Anyone preparing to move into Java backend development and Spring Boot

No previous Java or object-oriented programming experience is required.

The course begins with the fundamentals and gradually introduces stronger programming and software-design concepts.

## Go Beyond Java Syntax

Knowing Java syntax is important, but syntax alone does not make someone a strong developer.

Throughout the course, you will also learn how to reason about software.

You will explore questions such as:

* How should a larger problem be divided into smaller responsibilities?
* Which object should own a particular behavior or piece of state?
* When does an abstraction make a design better?
* When is a simpler solution the better choice?
* How can code remain understandable as an application grows?
* How do you recognize unnecessary complexity?

Object-oriented programming is taught in the same way.

Instead of simply memorizing concepts such as `encapsulation`, `inheritance`, `polymorphism`, and `abstraction`, you will learn:

* Why these concepts exist
* What problems they help solve
* Where they are useful
* What trade-offs they introduce
* When they should not be used

The focus is on developing judgment, not memorizing patterns.

## Learn by Building and Reasoning

The course progresses step by step.

You will begin with small programming problems and gradually work toward applications involving multiple classes, objects, relationships, abstractions, and collaborating components.

Throughout the course, you will work with:

* Practical coding exercises
* Predict-the-result challenges
* Knowledge checks
* Software-design questions
* Refactoring exercises
* Hands-on projects
* A larger final project

You will learn to evaluate more than whether your code works.

You will also learn to ask:

> Is this code clear?

> Are the responsibilities in the right place?

> Will this design be easy to change?

> Am I introducing complexity that I do not need?

That shift in thinking is where programming starts to become software engineering.

## What You Will Learn

You will build a foundation in:

* Programming logic and problem solving
* Variables, types, expressions, and control flow
* Methods and program structure
* Arrays and data processing
* Classes and objects
* Constructors and object state
* Encapsulation and invariants
* Object relationships
* Composition and delegation
* Immutability
* Packages and project organization
* Inheritance
* Method overriding
* Runtime polymorphism
* Abstract classes
* Interfaces
* Dependency design
* Constructor injection
* Refactoring and maintainability

The emphasis throughout the course is on understanding the reasoning behind these concepts rather than copying patterns mechanically.

## Learn in English — Translate with AI When You Need It

The course is written in **English**, using the terminology you will encounter in professional Java documentation, APIs, technical articles, codebases, and engineering teams.

Java keywords, APIs, class names, method names, and technical terminology remain consistent with industry usage.

If English is not your preferred learning language, Tarkev's **AI-assisted translation** allows you to translate lesson content into a supported language while you learn.

This can help you understand difficult explanations in a language that feels more comfortable while keeping you connected to the original English technical terminology.

You learn from the same course and can use translation whenever it helps.

## Build the Foundation for Java Backend Development

This course intentionally focuses on Java and software-engineering fundamentals before introducing frameworks.

Frameworks such as Spring Boot become much easier to understand when you already know the language and the design principles underneath them.

By developing these fundamentals first, you will be better prepared to understand concepts such as:

* Dependency injection
* Application architecture
* Service boundaries
* Domain modeling
* Data access
* API development
* Testing
* Backend application design

After completing this course, you will have the foundation needed to continue into **Java backend development and Spring Boot**.

## By the End of the Course

After completing the course, you should be able to:

* Build Java programs independently
* Read and understand existing Java code
* Break larger problems into smaller responsibilities
* Model problems using classes and objects
* Use encapsulation, inheritance, interfaces, and composition intentionally
* Organize Java applications more clearly
* Reason about maintainability and code quality
* Refactor unnecessarily complicated code
* Make better design decisions as applications grow
* Approach Java backend development with stronger fundamentals

Most importantly, you should begin thinking about code not only as something that needs to work, but as software that other people—including your future self—need to understand, change, and maintain.

**Learn Java. Understand the reasoning behind the code. Start building software like an engineer.**

Build a strong programming foundation with Java and learn how real software is designed using object-oriented principles.

Tarkev

About

Courses