Skip to content

Prove your Go skills

Go is easy to start and hard to write well at scale. Lemma captures how you handle goroutines, errors and interfaces in live work, so a team can see your Go before they set a take-home task.

How Go is assessed

What Go competence looks like

A strong Go developer writes boring code on purpose. They keep interfaces small and define them where they are consumed, return errors with context instead of panicking, and resist building abstractions the language does not need. Their packages have clear boundaries and their APIs are hard to misuse.

With concurrency, they know which problems actually need goroutines. They use channels for ownership and coordination, mutexes for shared state, and context for cancellation and deadlines. They run the race detector, write table-driven tests and profile with pprof before rewriting anything for speed.

Go session
Live · 41:07

Fixing a concurrency bug live

60 min · Learning · with Arjun S.

worker.go Rosa D. is sharing
12
13
14
15
16
17
18
19

Arjun S. rated the session

Practitioner · after the call

Clear reasoning on goroutines and channels. Talked through trade-offs first.

Added to GoAdded to record

Goroutines and channels

Coordinating work, avoiding leaks and deadlocks, and choosing channels or mutexes for the problem at hand.

Error handling

Wrapping errors with context, using errors.Is and errors.As, and keeping panics for truly unrecoverable states.

Interfaces and types

Small consumer-defined interfaces, embedding, generics where they help, and zero values that are useful.

Context and cancellation

Passing context through call chains, enforcing deadlines and shutting services down cleanly.

Testing and benchmarks

Table-driven tests, test helpers, benchmarks and the race detector as part of routine work.

Profiling and performance

Using pprof to find allocations and hot paths, and measuring before optimising.

What counts as evidence of Go skills?

A line on a CV saying Go is a claim. A reviewed session, an assessed level or a repository linked from your account is evidence. These are the kinds Lemma records against your Go skill, each with where it came from. See the evidence methodology for how each source is weighed.

Skills Passport
Signed
52

Go

Felix B. · SCI recomputed 9 Oct

Evidence · 4 entries

  1. Fixing a concurrency bug live

    Live session · 9 Oct

    Rated 5.0

  2. Go scenario questions

    Adaptive assessment · 2 Oct

    Level 7.2

  3. A Go service or CLI on GitHub

    GitHub connector · 24 Sep

    Verified

  4. Teaching Go concurrency

    Live session · 11 Sep

    Taught · 1.5x
Signature valid · checked today Share link
Live session

Fixing a concurrency bug live

A practitioner gives you a Go program with a race or a leaked goroutine. They watch how you find it, fix it and explain the cause, then rate the session.

Adaptive assessment

Go scenario questions

Adaptive multiple-choice questions cover slices, maps, interfaces and goroutine behaviour. Some show a Go snippet and ask you to choose the correct diagnosis or fix. Harder questions count for more.

GitHub connector

A Go service or CLI on GitHub

Connect a repository or a specific commit for something you built in Go. Lemma checks it exists and that your account has access, and re-checks it periodically.

Live session

Teaching Go concurrency

Walking another developer through channels, select and context is strong evidence of understanding. Teaching sessions carry more weight than learning sessions in your Go record.

How is a Go skills test run on Lemma?

The Go test runs 15 to 25 questions and adjusts difficulty to your answers, with scenarios from services under real load. The result counts alongside sessions and linked repositories toward your Go SCI, which favours recent evidence over old.

How the SCI score is calculatedHow adaptive skills assessments workPractise Go in live skill swap sessionsWhich evidence types countWhat your Skills Passport shows
Go assessment
0:42
Question 11Stops when your level holds
Difficulty7/10

A service panics with "concurrent map writes" under load. What fixes it?

  1. AAllocate the map with make
  2. BIncrease GOMAXPROCS
  3. CGuard the map with a mutex
  4. DRead it through a buffered channel
Locks on submit

  1. Practise idiomatic Go

    The AI tutor sets Go exercises on error handling, interfaces and concurrency, and adapts to how you answer. It is preparation: drill results add only a small, capped amount to your practice score.

  2. Pair with a Go practitioner

    Review a service or solve a concurrency problem in a live one-to-one session. Completion is recorded when you both join, and the practitioner's rating becomes part of your Go evidence.

  3. Complete the Go assessment

    Scenario questions move up or down in difficulty with each answer. Harder questions count for more, and some ask you to diagnose a Go snippet. Per-question time limits and no going back keep it meaningful.

Go skills: common questions

How can I prove Go experience if my current job uses another language?

Build the evidence outside your job. Work through Go problems in live sessions with practitioners, take the adaptive Go assessment and connect a repository for a side project or open source contribution. Your Passport then shows Go work directly, independent of what your employer runs in production.

What does a Go concurrency assessment look like?

On Lemma, questions describe realistic situations: a worker pool that hangs, a map written from several goroutines, a request that ignores cancellation. You pick the correct explanation or fix from the options. Difficulty adjusts after each answer, harder questions count for more, and you cannot go back.

Is Go a good second backend language to verify?

Go is widely used for services, infrastructure tooling and CLIs, so evidence in it pairs well with Docker, cloud and system design skills. If you already have a backend record in another language, adding Go evidence shows range and makes your Passport relevant to infrastructure-heavy teams.

What should a Go portfolio project show a hiring team?

Clear package structure, errors handled with context, tests that run with the race detector, and graceful shutdown using context. Connect that repository to Lemma as an external proof, then discuss its design in a live session so the reviewer's rating adds context the code alone cannot give.

Skills related to Go

Browse the skills directory

Docker

Show you can build small, secure images and debug containers when they misbehave.

Evidence for Docker

Cloud architecture

Show how you design cloud systems that scale, fail gracefully and stay affordable.

Evidence for cloud architecture

System design

Show how you reason about scale, failure and trade-offs, in live design sessions reviewed by practitioners.

Evidence for system design

DevOps

Evidence of how you build pipelines, ship safely and keep systems observable.

Evidence for DevOps

Start your Go evidence record.

Lemma is in early access. Request an invite and we will email you when your place is ready.