Tel. 02-570-8449 Mobile 088-807-9770 Payment
Mon–Fri 9:00–17:00 @itgenius
IT Genius Institute
IT Genius Institute
CoursesWorkshopSchedule
For business
In-house trainingAI Transformation (TH)Government training (TH)Development servicesTraining room rental
Articles
About us
About IT GeniusInstructorsPortfolioOur clientsPayment methods
Contact usOnline
Theme
Language
THENLA
Ask about a coursePick whichever channel suits you
LINE @itgeniusFastest reply · Mon–Fri 9:00–17:00
Call us
02-570-8449Office088-807-9770Mobile
Email & social
contact@itgenius.co.thFor quotations and documentsFacebookitgeniusonlineYouTubeitgeniusengPlan training for your team
Home / Courses / Web Development / Detail
Web Development · WDC-108

Go with Fiber Framework

Go with Fiber Framework is a hands-on course in building RESTful APIs with Go and Fiber v3, covering language essentials, middleware, MongoDB, JWT authentication with roles, Hexagonal Architecture, testing and Docker deployment. It suits backend developers and software teams who have built APIs before, and you leave able to ship a well-structured Fiber API to production.

Updated
Go with Fiber Framework
From 13,950 THB / person 15,500 −10% excl. VAT 7% · group rates available
Corporate training quote Join the waiting list
PDFDownload the course outline
  • Duration30 hours · 5 days
  • FormatOnsite / live online
  • Next roundOn request
  • CertificateIncluded

Course overview

Go has become a popular choice for backend teams because it compiles to a single binary, runs fast, uses little memory and handles large numbers of concurrent requests well. Fiber is a framework with an Express-like style, so developers who have built APIs before can get started quickly. Yet many examples online still use Fiber v2 and MongoDB Go Driver v1, whose APIs have since changed, so copying them into current projects leads to code that does not compile or is hard to maintain.

This course shows learners how to build RESTful APIs with Go 1.27 and Fiber v3. It starts with the Go essentials used in real work, including structs, interfaces, generics, error handling and concurrency with goroutines, channels and context. Learners then build an API with binding, validation and security middleware, connect to MongoDB with Go Driver v2, add JWT authentication with roles and permissions, structure the project with Hexagonal Architecture, write unit and integration tests, and take the application to Docker and the cloud. The course closes with a capstone that builds a complete API from start to finish. (5 days, 6 hours per day, 30 hours in total, Intermediate level.)

What you’ll gain

  • Write Go 1.27 fluently, including structs, interfaces, generics and error handling
  • Use goroutines, channels and context to write safe concurrent code
  • Build RESTful APIs with Fiber v3, including binding, validation and middleware
  • Store and query data in MongoDB with MongoDB Go Driver v2
  • Implement JWT authentication with roles and permissions
  • Design a Hexagonal Architecture project layout that is easy to test and extend
  • Write unit tests and integration tests for an API
  • Build Docker images and deploy to a server or the cloud

Who this course is for

  • Backend developers who want to start using Go and Fiber in real projects
  • Node.js, Python, PHP or Java developers who have built APIs and want faster, lighter services
  • Software teams who want to structure code with Hexagonal Architecture
  • Tech leads evaluating Go for new services in their organisation
  • Developers who learned Fiber v2 and want to update to Fiber v3

Prerequisites

  • Experience building RESTful APIs and working with JSON in any language
  • Understanding of HTTP methods, status codes, requests and responses
  • Programming experience in at least one language such as JavaScript, Python, PHP or Java; no prior Go needed
  • Some experience with SQL or NoSQL databases will help you learn faster
  • A laptop that can run Go, Docker Desktop and VS Code, with permission to install software

Curriculum

Course Details

This course is the 2026 edition that replaces the previous Go with Fiber framework course, which was taught on Fiber v2. It has been rewritten for Go 1.27, Fiber v3 and MongoDB Go Driver v2. It runs for 5 days, 6 hours per day (30 hours in total, 09:00-16:00), as lectures with labs built on a single API project that grows throughout the course. Intermediate level. New content covers generics, context, validation, security middleware, unit and integration testing, logging with log/slog, health checks and CI with GitHub Actions. Learners take home a lab guide, source code for every lab, and Dockerfile and docker-compose files. Cloud deployment uses the learner's own account.

Day 1 Go Language Essentials

Section 1: Lab: Getting Started with Go 1.27 and Its Tools

  • Why Go suits backend work and how it differs from Node.js, Python and Java
  • Install Go 1.27 and set up VS Code with the Go extension and gopls
  • Go modules, go.mod and managing dependencies with go get
  • go fmt, go vet and golangci-lint for code quality
  • Lab: create a first project and run a command-line program

Section 2: Everyday Go Syntax

  • Variables, data types, constants and zero values
  • Slices, maps and for range, including range over int and iterators
  • Functions with multiple return values, closures and defer
  • Go-style error handling with errors.Is, errors.As and wrapping with %w
  • Lab: write a program that processes data from a JSON file

Section 3: Structs, Methods, Interfaces and Generics

  • Structs and methods instead of classes, with pointer receivers
  • Embedding to reuse code instead of inheritance
  • Implicit interfaces and the principle of small interfaces
  • Generics for reusable functions and types
  • Lab: design the models and interfaces of a product management system

Section 4: Lab: Concurrency with Goroutines, Channels and context

  • Goroutines and channels, with select to wait on several channels
  • sync.WaitGroup, mutexes and errgroup for coordination
  • Cancel work and set timeouts with context
  • Detect race conditions with go test -race
  • Lab: call several external APIs concurrently and combine the results
Day 2 Building RESTful APIs with Fiber v3

Section 5: Lab: Meet Fiber v3 and Build a First API

  • What Fiber is, how it runs on fasthttp, and how it compares with net/http and Gin
  • What changed from Fiber v2 to v3, such as fiber.Ctx as an interface and ListenConfig
  • Routing, route groups, path parameters and query strings
  • Configure the app with fiber.Config and environment variables
  • Lab: build a first API and test it with Postman or Bruno

Section 6: Requests, Responses and Validation

  • Read input with c.Bind().Body(), Query() and URI() instead of BodyParser
  • Validate input with go-playground/validator through StructValidator
  • Return consistent JSON responses and status codes across the system
  • Write a central error handler that turns errors into clear responses
  • Lab: a product API with a complete set of validation rules

Section 7: Middleware in Fiber v3

  • How middleware is ordered, and writing your own middleware
  • Logger, Recover, Request ID and Compression
  • Security with Helmet, CORS and Limiter
  • Read middleware values with the new FromContext functions in v3
  • Lab: set up a standard middleware stack for the API

Section 8: Lab: A Well-Structured CRUD API

  • Separate handlers, services and repositories from the first project
  • Pagination, filtering and sorting through query strings
  • File upload with multipart forms and file type checks
  • Workshop: build a CRUD API for product management with in-memory storage
Day 3 MongoDB and Authentication

Section 9: Lab: MongoDB with Go Driver v2

  • Run MongoDB with Docker and explore data with MongoDB Compass
  • Connect with MongoDB Go Driver v2 and what changed from v1
  • Clients, databases, collections and connection pool settings
  • Define models with structs, BSON tags and ObjectIDs
  • Create indexes, including a unique index on user email

Section 10: Queries, Aggregation and Transactions

  • InsertOne, Find, UpdateOne and DeleteOne with different filters
  • Efficient projection, sorting and pagination
  • Aggregation pipelines for summary reports
  • Transactions on a replica set and when to use them
  • Lab: move the Day 2 CRUD API to store data in MongoDB

Section 11: Lab: Authentication with JWT

  • Design registration and login, storing passwords with bcrypt
  • Issue access and refresh tokens with golang-jwt v5
  • Verify tokens with the JWT middleware from Fiber Contrib
  • Logout, token expiry and storing secrets safely
  • Lab: a working sign-up and sign-in system

Section 12: Lab: Roles and Permissions

  • Design roles and permissions that match how the system is used
  • Middleware that checks permissions by role and by data ownership
  • Limit login attempts with Limiter
  • Common API weaknesses from the OWASP API Security Top 10
  • Lab: assign Admin, Staff and User permissions to the product API
Day 4 Hexagonal Architecture and Code Quality

Section 13: Hexagonal Architecture Concepts

  • The problem with business logic tied to frameworks and databases
  • Ports and adapters: domain, application and infrastructure
  • Dependency direction and package layout in Go
  • Layered, Clean and Hexagonal Architecture compared, sized to the team

Section 14: Lab: Refactoring the Project to Hexagonal

  • Define repository ports as interfaces and write a MongoDB adapter
  • Turn Fiber handlers into an HTTP adapter that calls use cases
  • Wire dependencies in main with constructor injection
  • Manage configuration and secrets through environment variables
  • Lab: refactor the product and user APIs into the new structure

Section 15: Lab: Testing the API

  • Table-driven unit tests with the testing package
  • Mock ports to test use cases without a database
  • Test routes with Fiber's app.Test()
  • Integration tests against a real MongoDB with Testcontainers for Go
  • Measure test coverage and agree a minimum for the team

Section 16: Logging, Health Checks and API Documentation

  • Structured logging with log/slog and request IDs
  • Liveness and readiness health checks with Fiber middleware
  • Graceful shutdown without dropping in-flight requests
  • Document the API with the OpenAPI standard for the frontend team
  • An overview of OpenTelemetry for tracing requests across services
Day 5 Build, Deploy and Capstone

Section 17: Lab: Building and Running the Project

  • Build a single binary and cross-compile with GOOS and GOARCH
  • Embed a version number with -ldflags and reduce binary size
  • Hot reload during development with Air
  • Collect common commands in a Makefile

Section 18: Lab: Docker and Docker Compose

  • Write a multi-stage Dockerfile
  • Choose a distroless or scratch base image for a small, secure image
  • Docker Compose for the API and MongoDB with volumes
  • Pass configuration and health checks through Compose
  • Lab: run the whole system with a single command

Section 19: Deploying to a Server and the Cloud

  • Deploy on a Linux server with systemd and Nginx as a reverse proxy
  • Deploy containers to the cloud, such as Google Cloud Run, AWS or DigitalOcean
  • CI with GitHub Actions: lint, test and build images automatically
  • A security and performance checklist before going to production

Section 20: Workshop: End-to-End Capstone API

  • Pick a brief, such as a meeting room booking or inventory system
  • Design the domain, ports and API the Hexagonal way
  • Build it with MongoDB, JWT, roles and middleware
  • Write tests and build a Docker image ready to deploy
  • Present the work, review the code together and plan next steps

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

Join the waiting list Ask about rounds

For organisations — in-house / private

  • Tailor the content to your team’s tools and projects
  • Your dates, at your office or live online
  • Quotation with tax ID for procurement
Corporate training quote

Instructors

Frequently asked questions

What are goroutines and channels in Go?

A goroutine is a very lightweight unit of concurrent work, started by putting go in front of a function call, and thousands can run at once with little memory. A channel passes data safely between goroutines: one side sends a value and the other waits to receive it, so they coordinate without shared variables and locks, and select lets you wait on several channels at once. In API code you should also pass a context so work can be cancelled or timed out when a request ends.

What are the steps to build a REST API with Go Fiber v3?

Create a Go module and install Fiber v3, create the app with fiber.New and register routes by HTTP method, such as app.Get and app.Post. In Fiber v3, handlers receive fiber.Ctx as an interface and read the body with c.Bind().Body() instead of the older BodyParser. Validate the input, return JSON with a status code, add middleware such as Logger, CORS and Helmet with app.Use, and start the server with app.Listen.

What is Hexagonal Architecture, and how does it make code easier to maintain?

Hexagonal Architecture, also called ports and adapters, keeps business logic at the centre, independent of frameworks and databases. The core defines ports as interfaces, such as a repository that must save and find data, and outer adapters, such as Fiber handlers or MongoDB code, implement them. Changing the database or framework then means changing only an adapter, and the logic is easy to test with mocks. It feels natural in Go because interfaces are implicit.

Who is the Go with Fiber Framework course for, and what should I know beforehand?

It suits backend developers who want to start using Go and Fiber, software teams interested in Hexagonal Architecture, and developers moving up from Fiber v2. You should have built RESTful APIs with JSON, understand HTTP requests and responses, and program in a language such as JavaScript, Python, PHP or Java. No prior Go is needed, and experience with SQL or NoSQL databases helps.

What will I be able to do after the Go with Fiber Framework course?

You will be able to write Go with structs, interfaces, generics and concurrency, build RESTful APIs with Fiber v3 with validation and security middleware, add registration and login with JWT plus roles and permissions, store data in MongoDB with Go Driver v2, structure projects with Hexagonal Architecture, write tests, and build Docker images to deploy to a server or the cloud. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.

Can the Go with Fiber Framework course be run in-house for our team?

Yes. It can be run in-house for your team, with examples adapted to your work, such as designing APIs around the business domain your team develops, or focusing on architecture and deployment for your environment. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.