Use type annotations, interfaces, union types, generics, narrowing, and discriminated unions. These tools make Effect’s typed success, failure, and dependency patterns feel natural.

See how callbacks, Promises, async/await, thrown exceptions, and rejected Promises behave. You will write small async examples and notice where ordinary JavaScript loses track of failures and cleanup.

Practice representing missing data, invalid input, and recoverable errors without crashing the program. This prepares you for Effect’s habit of making outcomes visible in types.

Trace how Effect grew from functional programming, typed error handling, fp-ts, ZIO, and production TypeScript needs. This chapter explains why Effect treats work, errors, resources, and services as values you can combine.

Create Effect values that describe console work, synchronous work, async work, success, and failure. You will separate describing a program from actually running it.

Run Effect programs at the outer edge of an app using the runtime. This chapter covers safe entry points, program boundaries, and why most business code should return effects instead of executing immediately.

Combine small effects into larger programs with pipe, map, flatMap, and generator syntax. You will build multi-step flows where each step can use the result of the previous one.

Use Option for missing values and Either for values that may fail before they become full effects. You will convert between Option, Either, and Effect when building practical control flow.

Use immutable collections such as Chunk, HashMap, HashSet, and related equality tools when ordinary arrays and objects are not enough. These structures help with predictable data handling in concurrent and functional code.

Create typed failures with Effect.fail, custom error classes, tags, and pattern matching. You will recover from known problems without hiding bugs or flattening every error into a string.

Handle defects, interruption, Exit, and Cause when work fails in deeper ways than a normal typed error. This gives you the vocabulary to debug fiber failures and decide what should be recovered, retried, logged, or allowed to crash.

Use Scope, acquireRelease, and finalizers to open and close files, connections, locks, and other resources safely. You will make cleanup happen even when work fails or gets interrupted.

Use Schedule to retry, repeat, delay, debounce, back off, and time out work. You will build policies for unreliable APIs, polling jobs, and operations that should not run forever.

Define services with Context so code can ask for a capability instead of importing a global object. You will pass clocks, loggers, repositories, clients, and other dependencies in a testable way.

Assemble services with Layers and provide them to programs. This chapter covers layer composition, shared resources, dependency graphs, and common mistakes when wiring an app.

Read configuration through Effect instead of scattering environment checks across the codebase. You will handle required values, defaults, secrets, parsing errors, and environment-specific settings.

Use Effect platform services for console output, file systems, paths, clocks, random values, and other runtime capabilities. This keeps core code portable across Node.js, browsers, tests, and other environments.

Validate JSON, environment values, forms, and API payloads with Schema. You will decode unknown data into trusted values and return useful validation errors when input is wrong.

Use Data, tagged errors, branded types, and schema transforms to make domain values harder to misuse. You will model IDs, money, dates, statuses, and commands with stronger guarantees.

Add structured logs from inside effects without passing logger objects everywhere. You will attach context, log levels, spans, annotations, and useful failure details.

Record metrics and traces so production behavior can be seen, not guessed. This chapter connects Effect programs to OpenTelemetry-style spans, counters, gauges, and timing data.

Run independent work at the same time with fibers, fork, join, race, and parallel collection helpers. You will control concurrency without losing typed errors, cancellation, or cleanup.

Coordinate fibers with Ref, SynchronizedRef, Queue, PubSub, Deferred, and Semaphore. You will build safe shared state, worker pools, notifications, backpressure, and one-time handoffs.

Process values over time with Stream, Sink, and Channel. You will handle files, paginated APIs, message queues, batching, backpressure, and streaming failures.

Call external HTTP services with Effect’s HTTP client tools. You will build requests, decode responses with Schema, handle status codes, apply retries, and keep client configuration in Layers.

Create typed HTTP routes that validate requests and return predictable responses. This chapter covers route design, handlers as effects, middleware, error mapping, and generated contracts where supported.

Use Effect SQL patterns for connection pools, queries, transactions, and repository services. You will keep database access typed, testable, and safely scoped.

Test Effect programs with test services, controlled time, mock dependencies, and assertions on success or failure. You will test retries, timeouts, logging decisions, and resource cleanup without slow or flaky tests.

Build a small command-line tool from argument parsing to file access, validation, logging, testing, packaging, and release. This end-to-end workflow shows how Effect code moves from a request to a usable artifact.

Build a web service that accepts a request, validates input, calls services, uses a database, logs and traces work, handles failures, and returns a typed response. This chapter ties together the main production workflow for Effect backends.

Use typed RPC when a client and server need to share contracts across a process boundary. You will structure request and response schemas, service implementations, client calls, and failure handling.

Use clustering patterns when work must run across multiple Node.js processes or machines. This chapter covers sharding, distributed workers, supervision, delivery concerns, and when clustering is more complexity than a project needs.

Wrap Promise-based libraries, callback APIs, existing services, and legacy TypeScript code so they behave well inside Effect. You will migrate gradually without rewriting an entire codebase at once.

Add bulkheads, rate limits, caches, circuit breakers, idempotency, and backpressure to Effect services. You will choose patterns based on the failure mode instead of adding retries everywhere.

Package Effect apps for Node.js, containers, serverless runtimes, browser bundles, and CI pipelines. This chapter covers build output, environment setup, health checks, dependency risks, and release checks.

Tune runtime behavior with custom runtimes, supervisors, FiberRefs, interruption boundaries, and concurrency limits. You will diagnose slow or noisy programs without guessing at the library internals.

Organize modules, services, layers, schemas, errors, tests, and workflows in a codebase that can grow. This chapter gives practical rules for keeping Effect code readable for teammates, not just clever for the author.

Map the Effect-TS ecosystem, common roles, project types, contribution paths, proof-of-skill projects, and community resources. You will know what to build next, how to keep current, and how to show real Effect ability to others.