← All courses

Tech

Effect: production-ready TypeScript applications

Errors, dependencies, concurrency and resilience in one composable model, adopted incrementally.

Indicative duration
2 to 3 days
Level
Intermediate
Delivery
On-site · Remote · Hybrid
Formats
  • In-house
  • Open session
  • Intensive bootcamp
  • Coaching / mentoring

Expected outcomes for your teams and business

What the training concretely changes, beyond the classroom:

  • Fewer bugs reaching production

    Errors are part of the types: every failure case, timeouts and retries included, is visible and handled before the code ships.

  • Predictable delivery of complex features

    Concurrency, orchestration and background work become composable building blocks rather than one-off code.

  • Fewer regressions

    Dependencies are explicit and swappable, so business logic is tested without spinning up infrastructure.

  • Value without a rewrite

    Effect is adopted incrementally in your existing codebase: the first module already pays off, no big-bang migration.

Learning objectives

By the end of the course, participants will be able to:

  • Explain which problems Effect solves and when it is (or is not) worth adopting
  • Write programs with typed errors and handle failures explicitly
  • Structure dependencies with services and layers, and test them easily
  • Orchestrate concurrent work with fibers, interruption and safe resource management
  • Add resilience (retries, timeouts, schedules) and observability to a service
  • Introduce Effect incrementally into an existing codebase

Audience

  • TypeScript developers building backends, APIs or complex frontends
  • Tech leads evaluating Effect for their team

Prerequisites

  • Solid TypeScript fundamentals (generics, unions)
  • Experience with Promises and async/await

Programme

  1. Module 1 Why Effect

    • The cross-cutting concerns of a real application
    • The Effect type: success, error and requirements
    • Evaluation vs execution
    • Running effects at the edges

  2. Module 2 Errors as first-class citizens

    • Expected errors vs defects
    • Typed error channels and catching by tag
    • Error accumulation and validation
    • From exceptions and Promises to Effect

  3. Module 3 Dependencies, services and layers

    • Declaring services with Context
    • Building and composing layers
    • Configuration and secrets
    • Swapping implementations for tests

  4. Module 4 Concurrency and resources

    • Fibers and structured concurrency
    • Interruption and cancellation
    • Scope and safe resource management
    • Bounded parallelism, queues and an overview of streams

  5. Module 5 Resilience and observability

    • Schedule: retries, backoff and repetition
    • Timeouts and fallbacks
    • Logging, metrics and tracing
    • Schema for validating data at boundaries

  6. Module 6 Adopting Effect in an existing codebase

    • Incremental adoption strategies
    • Interop with Promise-based libraries
    • Project structure and conventions
    • Common pitfalls and how to avoid them

Teaching approach

Around 70% hands-on. Each module alternates short concept sessions, live coding and exercises of increasing difficulty, starting from realistic code rather than toy examples. A running example service grows module after module, so participants see how errors, dependencies, concurrency and resilience fit together. Participants leave with the exercises, their solutions and the slides.

Tailored to your context

Before the session, a short call helps me understand your stack, your codebase and your team’s level. Exercises can then be built on your own code, and the balance between modules adjusted to what matters most for you: adopting Effect in an existing product is a different journey from starting a new one.

Let's talk about your needs

A programme to adapt, a team to train, a question about a format? Write to me and let’s discuss.

Get in touch

antoinecoulon.consulting@gmail.com

Go further