Biome developers build and maintain the Rust-powered unified JavaScript toolchain that replaces ESLint and Prettier with a single tool that lints, formats, and organizes imports at near-instantaneous speed — configuring biome.json for project-specific lint rules and format settings, integrating Biome into CI pipelines with biome ci that fails on both lint errors and formatting drift in a single pass, and migrating legacy ESLint and Prettier configurations through Biome's migration tooling that automatically translates existing rules. At remote-first technology companies, they serve as the developer experience engineers who consolidate the historically fragmented JavaScript code quality toolchain — eliminating the configuration overhead of coordinating ESLint, Prettier, eslint-config-prettier, and their respective plugin ecosystems into a single binary that installs instantly, configures in minutes, and runs an order of magnitude faster than the tools it replaces.
What Biome developers do
Biome developers configure biome.json — writing the project configuration that enables linting (linter.enabled: true), formatting (formatter.enabled: true), and import organization (organizeImports.enabled: true), with language-specific overrides for JavaScript, TypeScript, JSON, and CSS under the javascript, json, and css keys; configure formatter settings — setting formatter.indentStyle (space/tab), formatter.indentWidth, formatter.lineWidth, and formatter.lineEnding for consistent code formatting across all JavaScript and TypeScript files without Prettier; configure lint rules — enabling recommended rules with linter.rules.recommended: true, extending with specific rule groups (correctness, complexity, suspicious, pedantic, nursery, style, performance, security), and overriding individual rules with "error", "warn", or "off" severity; configure file-specific overrides — using the overrides array in biome.json to apply different rule sets or formatter settings to specific glob patterns (disabling certain rules for test files, applying different formatting to generated code); run lint and format — using biome lint for lint-only checks, biome format for formatting checks or biome format --write for in-place formatting, and biome check to run both lint and format in a single pass; configure CI — using biome ci which applies strict mode (no auto-fixes, exits non-zero on any issue) for deployment-blocking quality gates with a single command; migrate from ESLint and Prettier — using biome migrate eslint and biome migrate prettier to automatically translate .eslintrc and .prettierrc configurations into equivalent biome.json rules; integrate with editors — configuring the Biome VS Code extension for real-time lint feedback and format-on-save, setting "editor.defaultFormatter": "biomejs.biome" in VS Code settings; configure ignore patterns — using files.ignore in biome.json to exclude generated files, build output, and third-party code from lint and format checks, similar to .eslintignore and .prettierignore; enable JavaScript-specific lint rules — configuring javascript.globals for browser globals and Node.js globals, and using javascript.jsxRuntime: 'reactClassic' for projects without the automatic JSX transform; and configure the Biome daemon — understanding that biome start runs the Biome language server daemon for editor integration, and biome stop terminates it, providing sub-millisecond file analysis through the persistent process.
Key skills for Biome developers
- biome.json: linter; formatter; organizeImports; overrides; files.ignore; vcs integration
- Lint rules: recommended; correctness; complexity; suspicious; style; performance; nursery
- Formatter: indentStyle; indentWidth; lineWidth; lineEnding; attributePosition (JSX)
- CLI: biome lint; biome format; biome check; biome ci; biome migrate; --write flag
- ESLint migration: biome migrate eslint; rule mapping; suppression comments
- Prettier migration: biome migrate prettier; format parity; breaking differences
- Editor: VS Code extension; defaultFormatter; formatOnSave; lint diagnostics
- TypeScript: TypeScript lint rules; noExplicitAny; useConsistentType; useImportType
- CI: biome ci --reporter; GitHub Actions integration; exit codes; --reporter=github
- Overrides: glob patterns; test file exceptions; generated code; framework-specific
Salary expectations for remote Biome developers
Remote Biome developers earn $85,000–$148,000 total compensation. Base salaries range from $72,000–$122,000, with equity at technology companies where code quality toolchain performance, developer experience, and CI pipeline speed directly affect engineering team velocity, code review efficiency, and the consistency of JavaScript and TypeScript code quality across large monorepo codebases. Biome developers with ESLint and Prettier migration expertise for large codebases with complex rule configurations, monorepo-wide Biome adoption with project-specific override strategies, CI integration that reduces code quality check time from minutes to seconds, and demonstrated developer experience improvements from toolchain consolidation command the strongest premiums. Those with Biome combined with broader TypeScript code quality expertise — deep lint rule understanding and the ability to customize rules for domain-specific code quality requirements — earn toward the top of the range.
Career progression for Biome developers
The path from Biome developer leads to senior developer experience engineer (broader scope across the complete code quality toolchain — linting, formatting, type checking, testing, and CI pipeline design), platform engineer (owning the developer toolchain standards across an engineering organization), or TypeScript infrastructure engineer (combining Biome's code quality layer with TypeScript's type checking, build tooling, and the broader TypeScript ecosystem). Some Biome developers specialize into code quality culture leadership, establishing the lint rules, formatting standards, and code review practices that define an engineering organization's quality expectations. Others transition into contributing to the Biome open-source project — Biome's Rust codebase, active community, and frequent new rule development make it an accessible entry point for engineers interested in Rust or in improving the JavaScript tooling ecosystem. Biome developers with deep ESLint rule knowledge often become the engineers who design and document the organization-wide lint rule policy when adopting Biome as a replacement.
Remote work considerations for Biome developers
Building Biome-powered code quality pipelines for distributed engineering teams requires configuration documentation, editor setup guides, and rule migration standards that prevent distributed engineers from running conflicting ESLint and Biome configurations simultaneously, formatting files with Prettier when Biome is the designated formatter, or suppressing lint errors with ESLint-style disable comments that Biome doesn't recognize. Biome developers at remote companies establish a clear formatter authority — documenting that once Biome is adopted, Prettier configuration files (.prettierrc, .prettierignore) and the prettier npm package must be removed, and VS Code's defaultFormatter must be set to Biome to prevent formatting conflicts between the two tools on developer machines — because distributed engineers with existing Prettier setups frequently end up with files that oscillate between Biome and Prettier format on every save; document Biome's suppression comment syntax — // biome-ignore lint/suspicious/noExplicitAny: reason or // biome-ignore format: reason — because engineers from ESLint backgrounds use // eslint-disable-next-line which Biome ignores, creating lines that pass in editors but fail in CI; configure biome ci as the single CI gate — replacing separate ESLint and Prettier CI steps with a single biome ci command that checks both lint and format in one pass — and documenting that --reporter=github produces GitHub Actions annotations directly on PR diff lines rather than in CI log output; and establish the overrides pattern for test file exceptions — documenting the glob patterns that disable specific performance or security rules in test files where they're less relevant, to prevent distributed engineers from globally disabling useful rules to avoid test file false positives.
Top industries hiring remote Biome developers
- TypeScript-first engineering organizations modernizing their JavaScript toolchain where Biome's single-tool replacement for ESLint + Prettier eliminates the version compatibility matrix between eslint, prettier, eslint-config-prettier, and dozens of plugins that creates maintenance overhead in long-lived TypeScript repositories
- Monorepo organizations where Biome's performance advantage is most pronounced — analyzing thousands of TypeScript files in milliseconds compared to minutes for ESLint — making the code quality check fast enough to run on every file save in editor extensions rather than only in pre-commit hooks
- Developer experience platform teams standardizing code quality tooling across multiple engineering teams where Biome's single configuration file replaces the coordination of separate ESLint and Prettier configs across dozens of packages, reducing the surface area for configuration drift
- Startup engineering teams building new TypeScript codebases where Biome's zero-to-working configuration time and single-binary installation simplifies the initial project setup without requiring ESLint plugin research and Prettier integration configuration
- CI performance-focused organizations where code quality check time contributes meaningfully to PR feedback latency — replacing multi-minute ESLint + Prettier parallel jobs with a single sub-second Biome check reduces the iteration cycle for engineers waiting on green CI
Interview preparation for Biome developer roles
Expect configuration questions: write a biome.json for a React TypeScript project that enables recommended lint rules, uses 2-space indentation, sets 100-character line width, and disables the noConsole rule for test files using overrides — what the full configuration structure looks like. Migration questions ask how you'd migrate a project with a complex .eslintrc that uses eslint-plugin-react, @typescript-eslint, and import/order rules to Biome — what biome migrate eslint does, what it can and cannot automatically translate, and how you'd handle rules with no Biome equivalent. CI integration questions ask how you'd integrate Biome into a GitHub Actions workflow that annotates PR diffs with lint errors — what the biome ci --reporter=github command looks like in the workflow YAML. Suppression questions ask how a developer should suppress a specific Biome lint rule for a single line and how this differs from ESLint's syntax — what the // biome-ignore lint/rule/name: reason comment looks like. Editor questions ask what configuration changes are needed in VS Code to make Biome the default formatter and disable Prettier — what the settings.json entries look like. Rule discovery questions ask how you'd find all available Biome lint rules and their documentation — what the Biome website's rule reference provides and how the nursery category of rules differs from stable rules. Be ready to compare Biome with ESLint + Prettier — the performance difference, the rule coverage gap, and when legacy ESLint plugins without Biome equivalents prevent full migration.
Tools and technologies for Biome developers
Core: Biome 1.x; biome CLI; biome.json; @biomejs/biome npm package. Commands: biome check; biome lint; biome format; biome ci; biome migrate; biome rage; biome start/stop (daemon). Configuration: biome.json (project root or per-directory); extends (parent config); overrides (glob-based exceptions); files.ignore; files.include. Lint rule groups: correctness (bugs); complexity; suspicious; pedantic; style; performance; security; nursery (unstable). Formatter options: indentStyle (space/tab); indentWidth (2/4); lineWidth; lineEnding; trailingCommas; semicolons; quoteStyle; bracketSpacing. JavaScript-specific: javascript.globals; javascript.jsxRuntime; javascript.formatter; javascript.linter. TypeScript rules: noExplicitAny; useConsistentType; noUnsafeAssignment; useImportType; noArrayIndexKey. Import organization: organizeImports.enabled; import sorting; unused import detection. Editor: Biome VS Code extension (biomejs.biome); IntelliJ plugin; LSP protocol; format on save. CI: biome ci --reporter=github; --reporter=json; exit codes (0=ok, 1=error); GitHub Actions. Migration: biome migrate eslint; biome migrate prettier; .eslintrc conversion; prettierrc conversion. Suppression: biome-ignore lint/rule: reason; biome-ignore format: reason; biome-ignore-all (file level). Alternatives: ESLint (rule ecosystem, plugins, extensibility); Prettier (formatting only, more options); dprint (Rust-based formatter, plugin-based); oxlint (Rust linter, ESLint-compatible); standardjs (opinionated, no config).
Global remote opportunities for Biome developers
Biome developer expertise is in strong and rapidly growing demand globally, with Biome's emergence as the leading unified JavaScript toolchain replacement — with over 2 million weekly npm downloads, adoption by companies including Vercel, Cloudflare, and Astro for their internal toolchains, and recognition as the tool that concretely demonstrates the Rust-based JavaScript tooling performance advantage — creating demand for engineers who understand both Biome's configuration model and the ESLint and Prettier ecosystems that Biome replaces. US-based Biome developers are in demand at TypeScript-first engineering organizations consolidating their code quality toolchain, platform engineering teams standardizing developer tooling, and CI performance-focused companies where code quality check time contributes to PR feedback latency. EMEA-based Biome developers are well-positioned given Biome's strong European open-source community — Biome originated as Rome Tools (created by Sebastian McKenzie, creator of Babel and Yarn) and the European JavaScript community has been early adopters of Biome's unified toolchain approach. Biome's continued development — new lint rule categories, CSS formatting support, expanded language support, and growing plugin infrastructure — ensures sustained engineering demand as the JavaScript toolchain consolidates around faster native-compiled tools.
Frequently asked questions
What is the relationship between Biome and Rome, and how does Biome's approach differ from ESLint + Prettier? Biome is the community-maintained continuation of Rome Tools — Rome was the original project created by Sebastian McKenzie (creator of Babel and Yarn) that aimed to unify all JavaScript tooling into a single tool; after Rome Tools the company shut down, the open-source community forked and relaunched the project as Biome under the Biome organization. Architectural difference from ESLint: ESLint is a plugin-based linter written in JavaScript where rules are separate packages loaded as plugins (eslint-plugin-react, @typescript-eslint/eslint-plugin) — Biome's rules are built directly into the binary, written in Rust, and cannot be extended with external plugins (yet). Architectural difference from Prettier: Prettier is a JavaScript program that reprints code according to its style rules — Biome's formatter is Rust code that produces output with near-identical style to Prettier for most code patterns, with some intentional differences. Performance: Biome processes approximately 25 files per millisecond on a single CPU core; ESLint processes approximately 0.5 files per millisecond — a 50x difference that becomes significant for large codebases. Trade-offs: ESLint has thousands of community plugins covering framework-specific rules, accessibility, imports, and dozens of other domains — Biome's built-in rules, while growing, don't cover all ESLint plugin functionality. Migration path: most projects can migrate 90%+ of ESLint rules to Biome equivalents; the remaining rules either don't have equivalents or the Biome version is stricter. Coexistence: Biome and ESLint can run simultaneously during gradual migration.
How does Biome handle TypeScript-specific lint rules and how does it compare with @typescript-eslint? Biome has native TypeScript parsing (no TypeScript compiler required, unlike @typescript-eslint which requires parserOptions.project and a tsconfig.json) and includes TypeScript-specific lint rules in its rule set. Built-in TypeScript rules: noExplicitAny (ban explicit any type), useConsistentType (consistent type vs interface preference), useImportType (require import type for type-only imports), noUnsafeAssignment (ban assignment from any type), noUnsafeMemberAccess (ban member access on any type). Type-aware rules: @typescript-eslint's most powerful rules (like no-floating-promises, await-thenable, no-misused-promises) require full type information from the TypeScript compiler — Biome currently does not support type-aware rules, meaning rules that analyze the TypeScript type system rather than just the AST are not available. This is Biome's most significant gap versus @typescript-eslint for TypeScript-heavy codebases. Recommended approach: use Biome for all linting where type-awareness is not required (the majority of rules), and if type-aware rules are critical, run @typescript-eslint alongside Biome for only those specific rules. Performance impact: @typescript-eslint with type-aware rules requires running the full TypeScript compiler for each file, making it significantly slower than Biome's AST-only analysis — the teams that value type-aware rules most may need to accept the performance cost or run them only in CI rather than on every save.
How does biome migrate eslint work and what does it successfully convert versus require manual handling? biome migrate eslint reads the project's .eslintrc (or .eslintrc.json, .eslintrc.js, eslintrc.yaml) and .eslintignore files and generates or updates biome.json with equivalent Biome configuration. Automatic conversions: standard ESLint core rules (no-unused-vars, eqeqeq, prefer-const) map to Biome correctness and complexity rules; @typescript-eslint rules that have Biome equivalents (no-explicit-any → noExplicitAny, prefer-optional-chain → useOptionalChain) are mapped; ignore patterns from .eslintignore become files.ignore entries; severity levels (error/warn/off) are preserved. Not automatically converted: ESLint plugin rules where no Biome equivalent exists — eslint-plugin-react/jsx-no-leaked-render may not have a direct Biome equivalent; @typescript-eslint type-aware rules that require TypeScript compiler integration; framework-specific plugin rules (eslint-plugin-import, eslint-plugin-jsx-a11y) that Biome doesn't cover or covers differently. After migration: the tool reports which rules could not be migrated and suggests Biome alternatives or notes where coverage gaps exist; review the migration report and decide whether to accept Biome's incomplete coverage or run ESLint alongside Biome for specific uncovered rules. Suppression comment migration: existing // eslint-disable-next-line rule-name comments are not automatically converted to // biome-ignore lint/rule/name: reason — they must be manually updated or a search-replace script applied across the codebase.