Lesson 7 of 7

Navigate the Course Structure and Set Up Your Dev Environment

This lesson orients you to how the course is organised, what each module builds on, and what you need installed before you start writing code. By the end, you'll have a working local environment and a clear mental map of the modules ahead.

The Ten Modules at a Glance

Module

Core libraries

What you'll build

099

Intro to Go

stdlib, Cobra, Fiber

Go fundamentals, small CLI, basic web API

100

Prerequisites & Tools

(conceptual)

Mental model of Cardano and the Go stack

101

Interacting with the Node

gOuroboros

Connect, fetch blocks, check tip, read mempool

102

Building Simple Transactions

Bursa, Apollo, gOuroboros

Create wallet, build tx, sign, submit

201

Chain Indexing

Adder

Follow the chain and filter events

202

Querying the Blockchain

Adder + Dolos + Blockfrost

Store events, combine with historical queries

203

Applications & Smart Contracts

Apollo + Aiken

Mint/burn, lock/unlock, datums, redeemers

204

Serialising Data

CBOR, Protobuf, CDDL

Read and round-trip on-chain binary formats

301

Debugging

pprof, community channels

Diagnose problems across the stack

302

Contributing

Git, Blink Labs repos

Submit a PR to a real Cardano Go project

Modules 099–100 are conceptual and foundational. 101 and 102 are where you first touch the Cardano Go libraries. 201–204 build working backends. 301–302 are about shipping and sustaining your code.

How the Modules Build on Each Other

  099 (Go basics)
        │
        ▼
  100 (Cardano + tools)
        │
        ▼
  101 ── 102 ── 201 ── 202 ── 203 ── 204
  (node   (tx    (events (queries (contracts (CBOR/
  reads)  build)  stream)  + state)  + datums)  CDDL)
                                        │
                                        ▼
                                      301 ── 302
                                   (debug)  (contribute)
  • 101 and 102 are a pair. 101 reads from the node; 102 writes to it.
  • 201 and 202 are a pair. 201 reacts to events; 202 answers queries.
  • 203 depends on 102 and 201. Smart contract work needs transaction building and chain following.
  • 204 deepens understanding of what actually travels over the wire — it sharpens debugging intuition for every prior module.
  • 301 and 302 are cross-cutting and come after you can ship a working indexer.

You can skip around once you've done 099 and 100 — the modules state their prerequisites explicitly.

What You Need Installed

Go 1.24+

go version

Should report 1.24 or newer. The starter-kits in the course pin toolchain go1.24.1 or newer. Older Go versions will fail on go mod download.

Install from go.dev/dl if needed.

Git

git --version

Any modern version is fine. You'll clone several Blink Labs repos throughout the course.

A terminal and editor

The course assumes a Unix-style terminal (macOS, Linux, or WSL on Windows). Any editor that understands Go will do — VS Code with the Go extension, GoLand, neovim with gopls, etc.

curl and jq

Used in a few lessons for quick HTTP checks and JSON inspection.

curl --version
jq --version

(Later) Dolos or Dingo

A lightweight Cardano data node you'll set up in the dolos-setup lesson. Don't install it yet — the dedicated lesson covers it with full context.

The course defaults to Dolos (Rust, stable). Dingo is the Go-native alternative — same role, same Ouroboros socket semantics, but still maturing. Either works for everything downstream. Pick Dolos unless you have a specific reason to go all-Go.

(Later) Docker (optional)

Dolos can run as a binary or in Docker. Either works. If you already have Docker, you can use it; otherwise the binary path is fine.

Repos You'll Clone During the Course

Each lesson clones what it needs, but here's the full list so you can pre-clone if you want:

Repo

Used in

Purpose

blinklabs-io/gouroboros-starter-kit

101, 102.4

Small example programs for each mini-protocol

blinklabs-io/bursa

102.1

CLI + HTTP wallet backend

blinklabs-io/adder-library-starter-kit

201, 202

Pipeline examples with filters

txpipe/dolos

099 (dolos-setup)

Local Cardano data node (course default)

blinklabs-io/dingo

optional

Go-native alternative to Dolos — same role, different implementation

All are open source under Apache 2.0 or MIT. All are active — check the latest release on each repo's releases page if you hit version-sensitive issues.

Accounts and Keys You'll Need

A preprod wallet with test ADA

You'll need a Cardano wallet (Eternl, Lace, or Nami) configured for preprod — not mainnet, not preview. Switching networks in each wallet UI is usually under Settings.

Once set to preprod, request test ADA from the Cardano Testnet Faucet. 10,000 tADA is enough for everything in the course.

A Blockfrost preprod project ID (free)

blockfrost.io — create an account, create a preprod project, copy the project_id. Free tier is sufficient.

You'll use this in 102.2 for the initial Apollo examples and in 202.5 for backfilling historical data.

Environment Variables You'll Set

A small set of variables recurs across lessons. Pin them in your shell profile or a per-project .env:

# Set in 101.1 onwards
export CARDANO_NODE_SOCKET_PATH=/path/to/your/dolos.socket
export CARDANO_NODE_MAGIC=1                            # preprod

# Used in 102.2, 202.5
export BLOCKFROST_KEY=preprod<your key here>

Never commit a .env with real keys to version control. The course .gitignore excludes them by default.

The Course Repo Itself

You're reading this inside the course app. The app renders these lesson files from content/cardano-go-pbl/lessons/ and provides the agent tooling for the instructor and assessor skills.

If you want to run the app locally (to modify lessons, check assignment rubrics, or fork for your own cohort):

git clone <this repo>
cd cardano-go-pbl-app
npm install
npm run dev   # http://localhost:3000

Forking the course is a first-class use case. src/config/branding.ts and src/styles/globals.css are where you'd rebrand it.

A Mental Model for Working Through Lessons

Each lesson follows roughly this shape:

  • Why you care — the problem being solved
  • Prerequisites — what to have done first
  • Core concept — the minimum you need to understand
  • Step-by-step — hands-on with real commands and code
  • Common issues — the errors you'll probably hit
  • Practice tasks — small exercises to cement the idea
  • What's next — where this lesson feeds

If you get stuck on a step, the Common Issues section is almost always where to look first. The problems named there are the problems students actually hit.

You'll Know You're Set Up When

  • go version reports 1.24+
  • git --version works
  • You have a preprod wallet with at least 1000 test ADA
  • You have a Blockfrost preprod project ID saved somewhere safe
  • You've located the course repo on disk and can render lessons locally (optional)

What's Next

You're ready to start. Recommended path:

  • Jump to Module 099 if you want to sharpen Go fundamentals first
  • Jump to 099 — Setting Up Dolos if you're confident in Go and want to start with infrastructure
  • Jump to Module 101 once Dolos is running

The rest of the course is just this: one module at a time, building the all-Go Cardano stack piece by piece.