EraCode practice
Browse community-shared practice across technologies. These pages are teasers only — skill maintenance still happens when you attempt the full challenge inside EraCode.
Practice composing object shapes in TypeScript using structural typing. One quiz + one tiny coding gap.
Quick Zod practice on environment/config parsing: interpret env strings safely and provide a sensible default.
Practice a focused Next.js modules/imports skill: using a TypeScript path alias to avoid brittle relative imports.
Practice an optimization pattern in Express: let clients reuse cached responses by supporting conditional GETs with ETags.
Practice a small routing/navigational pattern: choosing the right handler for a URL path using a compiled route table.
Practice using SQL module-like organization via schemas by calling a function from a different schema safely and explicitly.
Practice PostgreSQL conditional logic by classifying rows into a small set of status labels using CASE, and sanity-checking the results with simple queries.
Practice Tailwind CSS accessibility by applying a keyboard-only focus indicator using the `focus-visible` variant—without adding noisy focus styles for mouse users.
Practice Git file I/O hygiene by marking a tracked or untracked build artifact as locally ignored using Git’s index/info exclude mechanism.
Practice a small UI/styling pattern in C: emitting ANSI escape sequences to color terminal output without breaking resets.
Practice a fast, real-world Docker dependency-injection pattern: keep the build context clean so only the intended dependency manifests get sent to the daemon and used for caching.
Practice container-to-container routing by attaching a running container to a user-defined bridge network and verifying name-based reachability.
Quick practice on string normalization for SEO-friendly routing in Next.js: understand when to redirect and implement a tiny slug canonicalizer.
Practice designing and consuming a typed response shape from a third-party API using a discriminated union so callers can safely branch on success vs error.
Practice iterating over an object’s key/value pairs while preserving key types in TypeScript.
Practice Django dependency injection via template context processors: identify the right hook and implement a tiny request-aware injector.
Practice advanced routing/navigation by encoding a swap state into a canonical URL querystring and ensuring it round-trips reliably.
Practice a small but real-world DRF configuration task: enable the Browsable API only in development while keeping production JSON-only.
Practice a small but common Flask core API detail: returning an empty response with the correct status code (and no accidental body).
Practice wiring Sequelize into request flow: start a transaction in middleware, make it available to downstream handlers, and ensure it commits/rolls back correctly.
Practice a small Sequelize optimization: make `findAndCountAll` generate a leaner count query when you have includes that can inflate work.
Practice R package lifecycle/initialization by wiring a one-time setup hook correctly and reasoning about when it runs.
Practice a small but nuanced environment/config pattern in R: reliably reading a configuration value from an environment variable while providing a deterministic default.
Quick check + one small coding gap on module/import patterns: choosing a strategy for optional dependencies and implementing a lazy import fallback.