How to Hire Remote TypeScript Developers: A Complete Guide

• As teams plan how to hire remote TypeScript developers, 58% of US workers can work from home at least one day per week and 35% full‑time remote (McKinsey & Company, 2022).
• 83% of employers say the shift to remote work has been successful, supporting distributed engineering productivity (PwC US Remote Work Survey).
• The global pool continues to expand, with 28m+ software developers worldwide, widening sourcing opportunities (Statista).

Which core competencies are essential for remote TypeScript roles?

Core competencies essential for remote TypeScript roles include deep TypeScript fluency, modern framework expertise, backend and testing strength, and distributed delivery habits aligned to a remote typescript hiring guide.

1. TypeScript language depth

• Strong grasp of typing fundamentals, structural typing, unions/intersections, generics, mapped and conditional types, and module augmentation.
• Ability to model complex domains with precise, maintainable types that evolve with business logic and API contracts.
• Reduces runtime defects, improves refactor confidence, and raises code readability, enabling faster onboarding in distributed teams.
• Supports safer API boundaries across services and packages, preventing integration regressions across time zones.
• Applied via strict tsconfig settings, incremental typing of legacy JS, custom type utilities, and consistent declaration file hygiene.
• Used to encode invariants, enforce domain rules at compile time, and improve DX through intelligent tooling and autocomplete.

2. Frontend frameworks (React, Angular, Vue)

• Proficiency in JSX/TSX patterns, React hooks with types, Angular decorators and DI, or Vue SFCs with Composition API and Vite.
• Familiarity with state management (Redux Toolkit, NgRx, Pinia), routing, and performance patterns with types.
• Enables faster feature delivery and predictable behavior across browsers and devices in remote collaboration.
• Aligns component contracts with typed props, events, and store slices, reducing review cycles and regressions.
• Implemented through typed store slices, reusable components, Storybook docs, and accessibility checks integrated with CI.
• Leveraged with SSR/SSG frameworks (Next.js, Nuxt) and edge deployment to meet performance and SEO goals.

3. Node.js and backend APIs

• Comfort with Node.js runtimes, Express/Fastify, NestJS, and typed database layers using Prisma or TypeORM.
• Knowledge of REST and GraphQL schemas, validation, observability, and secure configuration management.
• Delivers clear service boundaries, measurable SLAs, and reliable integrations with typed contracts end‑to‑end.
• Improves maintainability and incident response, keeping distributed teams aligned on service behavior and logs.
• Implemented via schema‑first design, Zod/IO‑TS validation, OpenAPI/GraphQL SDL, and typed clients shared across repos.
• Instrumented through logs, metrics, and traces with tools like OpenTelemetry, ensuring actionable production insights.

4. Testing and quality practices

• Experience with Jest/Vitest, React Testing Library, Cypress/Playwright, and contract tests for APIs and events.
• Familiarity with type‑driven test strategies, coverage targets, and mutation testing for critical paths.
• Builds confidence for frequent releases without synchronous gatekeeping, a key enabler for hire typescript developers remotely.
• Reduces flaky releases and support burden, protecting developer focus and cycle time in distributed workflows.
• Executed with test pyramids, CI parallelization, feature flags, and canary releases backed by metrics.
• Enforced via branch protection rules, PR templates, and automated checks providing fast feedback loops.

5. Remote collaboration proficiency

• Skill with async communication, concise technical writing, architectural decision records, and shared RFCs.
• Comfort with tools like GitHub Projects, Jira, Linear, Slack threads, Loom, and documentation portals.
• Keeps teams unblocked across time zones, raising throughput without meeting overload and context loss.
• Clarifies decisions and trade‑offs, creating institutional memory that accelerates onboarding and reduces rework.
• Applied through daily updates, decision logs, scoped PRs, and issue templates that capture intent and outcomes.
• Reinforced with pair programming windows, office hours, and recorded demos for transparent progress.

Get a role‑ready competency checklist for TypeScript remote recruitment

Which steps form an effective remote TypeScript hiring process?

An effective remote TypeScript hiring process follows clear role scoping, multi‑channel sourcing, calibrated assessments, structured interviews, and decisive offers.

1. Role definition and scorecards

• Define outcomes, seniority level, domain context, tech stack, and reporting lines with explicit success metrics.
• Create a skills matrix across language, framework, backend, testing, cloud, and remote collaboration behaviors.
• Aligns interviewers and reduces bias, ensuring consistent decisions and faster time‑to‑offer across candidates.
• Signals clarity to candidates, improving response rates and fit, central to a remote typescript hiring guide.
• Implemented via a one‑page brief, competency rubrics, and example deliverables tied to goals and SLAs.
• Version‑controlled in the repo/wiki, refined after each hiring cycle with data from debriefs.

2. Sourcing channels

• Mix inbound job posts, curated communities, OSS contributors, outbound outreach, and specialized partners.
• Target regions with overlapping time zones and strong TypeScript ecosystems for efficient pipelines.
• Expands reach beyond local markets, lowering vacancy risk and improving diversity of thought.
• Increases pipeline quality by meeting developers where they engage, code, and learn.
• Executed via GitHub issue outreach, community newsletters, conference slacks, and referral programs.
• Tracked with UTM tags and ATS stages to double down on channels with best conversion.

3. Screening and coding assessments

• Short async screen on experience, domain familiarity, and constraints, followed by a calibrated code task.
• Use realistic tasks mirroring the role’s stack and scale, scored against a rubric.
• Filters for practical ability over trivia, producing signals that line up with on‑the‑job success.
• Respects candidate time, improving acceptance and completion rates in typescript remote recruitment.
• Delivered via sandboxed repos, lint/type checks enabled, and unit tests to verify acceptance criteria.
• Graded blind where possible, with debrief notes stored for auditability and fairness.

4. Technical interviews and system design

• Combine language deep dives, framework scenarios, API design, testing approach, and operational thinking.
• Include architectural trade‑offs, scalability, resilience, and data modeling with typed interfaces.
• Surfaces signal on seniority, autonomy, and judgment under realistic constraints.
• Minimizes bias through structured prompts, time‑boxed sections, and consistent probes.
• Run with shared docs, diagramming boards, and pre‑shared prompts to reduce anxiety and noise.
• Calibrated with shadow interviewers and regular score drift reviews.

5. Reference checks and offer process

• Speak with former managers and peers on collaboration, impact, reliability, and growth trajectory.
• Validate role‑aligned strengths and note coaching areas with concrete examples.
• Reduces risk of mis‑hire and improves onboarding planning and mentorship pairing.
• Increases close rates by addressing concerns early and aligning expectations.
• Offers include transparent comp bands, leveling rationale, benefits, and start logistics.
• Close decisively with timelines, optional sign‑on incentives, and clear next steps.

Want a turnkey pipeline to hire TypeScript developers remotely? Get a calibrated process map

Which sourcing channels reliably find remote TypeScript developers?

Reliable channels include OSS communities, professional networks, targeted job boards, and specialized partners that continuously engage TypeScript talent.

1. Developer communities and forums

• Active groups across Discord, Slack, Reddit, and conference communities focused on TS, React, Node, and tooling.
• Event CFPs, meetups, and webinars where contributors showcase talks, libraries, and case studies.
• Improves authenticity and trust, attracting builders invested in ecosystem growth.
• Produces referrals and warm intros, often outperforming cold outreach for senior profiles.
• Engage via AMAs, sponsor content, mentorship circles, and issue triage sessions.
• Track community ROI by shared links, unique codes, and contribution follow‑ups.

2. GitHub and open‑source contributions

• Stars, commits, issues, PRs, and maintainership across TypeScript‑heavy repos indicate craft and consistency.
• Contribution graphs and code reviews highlight depth across domains and patterns.
• Reveals engineering values, collaboration styles, and impact on real projects.
• Surfaces niche expertise in libraries, build systems, and typed API clients.
• Outreach through respectful issue threads, sponsor badges, or contributor programs.
• Evaluate with repo heuristics, PR narratives, and cross‑project involvement.

3. Professional networks and referrals

• LinkedIn, alumni groups, and prior teammates provide context‑rich recommendations.
• Internal referral programs with clear prompts and bonuses incentivize signal‑rich leads.
• Reduces uncertainty and shortens cycles through trusted endorsements.
• Improves retention by aligning expectations and team norms from day one.
• Launch referral drives tied to specific roles, regions, or frameworks.
• Maintain a living talent map with noted strengths and availability.

4. Remote job boards

• Niche boards oriented to global engineering roles with TypeScript tags and filters.
• Options span general remote platforms and stack‑specific boards.
• Delivers steady inbound interest at predictable cost per applicant.
• Enables targeted campaigns by region, time zone, and seniority.
• Use structured postings with role outcomes, stack, leveling, and comp bands.
• Iterate ad copy via A/B tests on headlines, benefits, and responsibilities.

5. Specialized staffing partners

• Agencies focused on TypeScript ecosystems and distributed delivery models.
• Pre‑vetted pools with skills verification, language checks, and references.
• Accelerates shortlisting, crucial for urgent backfills and surge staffing.
• Reduces internal load on sourcing and initial screening, preserving team focus.
• Engage with SLAs, replacement guarantees, and transparent fee structures.
• Calibrate by sharing rubrics, sample tasks, and high‑signal resume patterns.

Scale TypeScript remote recruitment with curated shortlists and SLAs

Which methods validate TypeScript expertise during assessments?

Validated methods include typed code tasks, rubric‑based reviews, scenario prompts on advanced types, and end‑to‑end exercises reflecting real services.

1. Static typing scenarios

• Exercises with strict tsconfig, domain modeling, and refactors that stress type soundness.
• Edge cases around nullability, discriminated unions, and exhaustive checks.
• Ensures compile‑time guarantees map to business invariants, reducing prod bugs.
• Builds confidence that code is safe to change without brittle side effects.
• Delivered via tasks that require improving types in partially typed codebases.
• Evaluated with criteria on correctness, clarity, and ergonomic DX.

2. Generics and advanced types

• Prompts that require reusable generic utilities, conditional and mapped types.
• Library augmentation and type inference challenges in realistic modules.
• Distinguishes surface‑level syntax from deep modeling capability.
• Correlates with performance on complex codebases and SDKs.
• Implemented with utility type creation, variance constraints, and inference tests.
• Scored on expressiveness, safety, and maintainability over cleverness.

3. Async patterns and Promise flows

• Tasks combining async/await, error propagation, cancellation, and concurrency control.
• Streaming APIs, backoff strategies, and resource cleanup in typed contexts.
• Reveals understanding of reliability and latency trade‑offs in services.
• Links to real uptime goals and user experience under load.
• Simulated via API wrappers, retries, and typed event emitters in tests.
• Judged by clarity, robustness, and observability signals baked in.

4. Framework‑specific tasks

• React component typing, Angular DI and modules, or Vue Composition API patterns.
• State modeling, forms with validation, routing, and data fetching with types.
• Indicates readiness to ship features in the target stack fast.
• Lowers onboarding time by aligning mental models with team code.
• Built as mini features with tests, Storybook stories, and docs.
• Assessed on accessibility, performance, and component API ergonomics.

5. Testing challenges

• Unit, integration, and E2E prompts with Jest/Vitest and Playwright/Cypress.
• Contract testing of APIs and events using typed schemas and mocks.
• Confirms discipline in preventing regressions and flaky pipelines.
• Speeds safe deployment cadence across distributed teams.
• Implemented with factories, fixtures, and CI parallelization.
• Graded on coverage quality, determinism, and meaningful assertions.

Need battle‑tested TypeScript assessment templates and rubrics? Request examples

Which signals confirm remote readiness and communication strength?

Reliable signals include crisp async writing, documentation hygiene, timezone awareness, ownership mindset, and tool proficiency.

1. Async writing quality

• Clear status updates, decision logs, and PR descriptions that stand alone.
• Specificity, structure, and tone that reduce back‑and‑forth.
• Keeps projects moving without meetings, reducing blockers.
• Creates durable artifacts future teammates can trust.
• Collected via writing samples, PR history, and RFC excerpts.
• Scored with a rubric on clarity, completeness, and actionability.

2. Time‑zone coordination

• Calendar discipline, handoff notes, and overlap planning for critical paths.
• Familiarity with follow‑the‑sun workflows and escalation ladders.
• Maintains momentum across regions with predictable cadence.
• Limits idle time and rework from missed context.
• Demonstrated through sample schedules and handoff templates.
• Tracked via SLA adherence and response metrics.

3. Documentation habits

• ADRs, runbooks, onboarding guides, and diagrams stored in a central hub.
• Consistent updates tied to releases and architecture changes.
• Reduces knowledge silos and bus factor risk in remote teams.
• Accelerates onboarding and incident resolution with living docs.
• Evidenced via wiki quality, diagram currency, and README standards.
• Measured through doc review gates in PR workflows.

4. Autonomy and ownership

• Proactive scoping, risk calls, and solution proposals without micromanagement.
• Regular demos and retros that reveal judgment and learning.
• Raises delivery reliability in low‑meeting environments.
• Frees managers to focus on strategy over task triage.
• Assessed via portfolio walkthroughs and scenario prompts.
• Confirmed with references highlighting initiative and follow‑through.

5. Tool proficiency

• Mastery of Git workflows, task boards, CI/CD dashboards, and observability tools.
• Comfort with Loom, Miro, and diagramming in technical discussions.
• Improves throughput and reduces coordination overhead.
• Enhances visibility across stakeholders and squads.
• Verified in ride‑along sessions and sandbox tasks.
• Reinforced with internal playbooks and tool training.

Strengthen remote‑first signals in your interview loop with our playbooks

Which compensation and contract models suit remote TypeScript hires?

Suitable models align salary bands to region and seniority, balance total rewards, and choose FTE or contractor routes with clear IP and compliance terms.

1. Market benchmarking

• Regional salary data segmented by experience, framework stack, and company stage.
• Bands published upfront with currency, pay frequency, and review cadence.
• Sets fair expectations and reduces negotiation churn and attrition risk.
• Supports equitable offers across locations and cohorts.
• Built from credible datasets and periodic refresh cycles.
• Governed by comp committees and structured leveling guides.

2. Total rewards beyond salary

• Health and wellness benefits, home office stipends, learning budgets, and equity.
• Flexible schedules, focused‑time policies, and paid time off programs.
• Improves acceptance rates and long‑term engagement.
• Differentiates offers when cash ranges overlap competitors.
• Implemented with transparent summaries and eligibility rules.
• Reviewed annually with feedback and market shifts.

3. Contractor vs full‑time selection

• Decision based on scope, duration, compliance, and need for leadership presence.
• Contractor vehicles include EOR, PEO, or direct agreements per jurisdiction.
• Balances speed and flexibility against retention and continuity.
• Manages risk around misclassification and local regulations.
• Enabled through vetted global payroll/EOR partners and clear scopes.
• Audited periodically with legal counsel and finance.

4. IP and confidentiality terms

• NDAs, invention assignment, and work‑for‑hire clauses in clear language.
• Repo access scoped to least privilege and revocation procedures.
• Protects trade secrets and reduces legal exposure.
• Ensures clean ownership for future funding or exits.
• Enforced via onboarding checklists and offboarding playbooks.
• Monitored through access audits and credential vaults.

5. Trial projects and probation

• Paid trial sprints or milestone‑based pilots with defined deliverables.
• Probation timelines with explicit performance outcomes and support.
• Lowers hiring risk and surfaces collaboration fit early.
• Builds mutual confidence before long commitments.
• Structured via sprint goals, review ceremonies, and success rubrics.
• Documented results inform conversion or extension decisions.

Design competitive, compliant offers for global TypeScript hiring

Which onboarding steps accelerate remote TypeScript productivity?

Effective onboarding provides fast environment setup, codebase orientation, standards, mentorship, and a 90‑day delivery roadmap.

1. Environment and access setup

• Pre‑provisioned laptops, VPN, secrets, package registries, and CI runners.
• One‑click scripts for Node/PNPM/Yarn, tsconfig, and lint formatting.
• Eliminates first‑week friction and shadow IT risks.
• Accelerates first commits and reduces support tickets.
• Implement via golden images, bootstrap scripts, and access checklists.
• Track time‑to‑first‑PR and access SLA compliance.

2. Codebase tour and architecture docs

• Overview of modules, boundaries, data flows, and domain models.
• Diagrams of services, ownership maps, and deployment topologies.
• Creates shared mental models for safe changes early.
• Reduces accidental coupling and regression risk.
• Delivered with guided READMEs, walkthrough videos, and ADR indices.
• Updated with release trains and migration plans.

3. Guardrails: coding standards and CI

• Style guides, lint/type rules, commit conventions, and PR templates.
• CI pipelines with tests, checks, previews, and required approvals.
• Raises quality while enabling frequent merges across time zones.
• Cuts review cycles by clarifying expectations upfront.
• Implement via shared ESLint configs, tsconfig bases, and reusable workflows.
• Measure with lead time, review latency, and change failure rate.

4. Mentorship and feedback cadence

• Assigned buddy, weekly 1:1s, and regular code walkthroughs.
• Clear channels for questions, decisions, and escalation.
• Increases confidence and belonging in distributed settings.
• Surfaces blockers early before schedules slip.
• Run with calendar holds, office hours, and recorded sessions.
• Monitor with pulse surveys and ramp‑up checkpoints.

5. First‑90‑day roadmap

• Goals spanning domain learning, 1–2 features, and a quality or tooling improvement.
• Milestones mapped to increasing autonomy and scope.
• Builds momentum and early wins tied to team outcomes.
• Clarifies expectations shared by manager and peer mentor.
• Captured in a living doc with weekly updates and demos.
• Reviewed at 30/60/90 days with documented feedback.

Accelerate time‑to‑first‑PR with a proven TS onboarding kit

Which performance practices sustain delivery and growth?

Sustaining practices include outcome‑based goals, quality gates, reliability rituals, continuous learning, and intentional retention programs.

1. OKRs and measurable outcomes

• Objectives tied to product impact with KRs for latency, conversion, or churn.
• Engineering metrics like lead time, deployment frequency, and incident counts.
• Focuses effort on user value rather than busywork.
• Aligns squads and stakeholders around clear targets.
• Implement via quarterly planning and weekly business reviews.
• Visualize in dashboards accessible to all contributors.

2. Code review and quality gates

• Reviews centered on clarity, correctness, and maintainability with typed APIs.
• Automated checks for linting, types, tests, and bundle budgets.
• Decreases defect rate and rework across distributed PR flows.
• Supports mentoring through constructive, consistent feedback.
• Configure branch protections, required statuses, and CODEOWNERS.
• Track review latency, change size, and rollback frequency.

3. Incident and reliability routines

• SLIs/SLOs, runbooks, on‑call rotations, and blameless postmortems.
• Error budgets steering release pace and risk appetite.
• Improves reliability and customer trust over time.
• Prevents burnout with measured, learn‑and‑improve cycles.
• Enact with alert tuning, chaos drills, and incident tooling.
• Publish action items and owners with due dates.

4. Learning and upskilling pathways

• Budgets for courses, conferences, and certs across TS, frameworks, and cloud.
• Internal guilds, brown bags, and pair rotations across services.
• Keeps skills current in fast‑moving ecosystems.
• Encourages cross‑team empathy and shared standards.
• Run LMS tracks, reading lists, and quarterly learning goals.
• Recognize contributions via badges, promos, and comp levers.

5. Retention and engagement loops

• Career ladders, recognition rituals, and transparent promotion paths.
• Regular pulse checks, skip‑levels, and compensation reviews.
• Curbs attrition and preserves domain knowledge.
• Strengthens team cohesion and psychological safety.
• Execute engagement surveys with actioned follow‑ups.
• Offer internal mobility and leadership opportunities.

Level up delivery with measurable engineering practices and coaching

Which risks deserve proactive controls in remote TypeScript delivery?

Key risks include knowledge silos, security gaps, timezone handoffs, scope drift, and platform lock‑in, each mitigated with specific controls.

1. Bus factor and knowledge silos

• Single‑owner modules, tribal knowledge, and sparse docs.
• Fragile dependencies on individuals for builds or releases.
• Threatens continuity during leave or attrition events.
• Slows onboarding and creates bottlenecks at review time.
• Countered with pairing, ownership maps, and redundancy plans.
• Audited via coverage of docs, reviewers, and on‑call depth.

2. Security and compliance posture

• Secrets sprawl, unpatched packages, and loose access controls.
• Incomplete audit trails and weak dependency policies.
• Increases breach likelihood and regulatory exposure.
• Erodes customer trust and delays enterprise deals.
• Managed with SAST/DAST, SBOMs, SSO, and least privilege.
• Verified through periodic pen tests and compliance checks.

3. Time‑zone and handoff risks

• Gaps in overlap windows and inconsistent handoff notes.
• Latency in decisions for cross‑team dependencies.
• Leads to idle cycles and deadline slips.
• Multiplies misunderstandings and duplicate efforts.
• Addressed with handoff templates and decision records.
• Coordinated via defined overlap hours and escalation trees.

4. Scope creep and backlog health

• Vague acceptance criteria and shifting priorities.
• Long‑lived branches and stale tickets without owners.
• Blurs accountability and inflates cycle time.
• Pushes defects downstream and strains QA capacity.
• Controlled through backlog hygiene and sprint exit criteria.
• Measured with WIP limits, flow efficiency, and age of work.

5. Vendor lock‑in and single‑cloud risk

• Proprietary services and SDKs without portability plans.
• Tight coupling to provider auth, storage, and messaging.
• Limits negotiation leverage and migration options.
• Raises downtime exposure from regional incidents.
• Mitigated with abstraction layers and multi‑region strategies.
• Tested via failover drills and portable IaC modules.

Reduce delivery risk with proven controls and readiness reviews

How to hire remote TypeScript developers on a tight timeline?

To hire remote TypeScript developers quickly, compress cycles with role clarity, parallelized sourcing, calibrated assessments, and fast, transparent decisioning.

1. Parallelize the pipeline

• Run sourcing, screening, and scheduling concurrently with clear SLAs.
• Maintain candidate pools by seniority and region ready to engage.
• Shortens elapsed time without compromising signal quality.
• Keeps momentum so top talent remains engaged and responsive.
• Enable with dedicated coordinators and calendar automation.
• Track per‑stage throughput and conversion to identify stalls.

2. Optimize the assessment

• Use a single realistic task aligned to the role and stack.
• Share expectations, rubric, and time budget upfront.
• Produces high‑fidelity signal in fewer steps.
• Reduces candidate fatigue and abandonment rates.
• Provide starter repos, typed stubs, and sample tests.
• Grade within 24–48 hours and schedule next steps immediately.

3. Tighten interview loops

• Consolidate interviews into focused blocks with structured prompts.
• Pre‑brief panels and avoid duplication across sessions.
• Cuts context switching and calendar delays for all sides.
• Improves fairness and consistency of evaluation.
• Use shared scorecards submitted before group debriefs.
• Decide within 24 hours with clear outcomes and action items.

4. Pre‑approved offers

• Align on compensation bands and templates before sourcing.
• Draft contracts and compliance checks ready for quick issuance.
• Prevents end‑stage delays that lose candidates to competition.
• Builds trust through transparency and speed.
• Prepare region‑specific agreements via EOR partners.
• Send offer summaries with explainer notes and timelines.

Need to fill a TypeScript role in under two weeks? Engage a fast‑track pipeline

Faqs

1. How long does it take to hire remote TypeScript developers?

• Most teams complete sourcing, assessments, and offers in 2–6 weeks, depending on seniority, assessment depth, and decision velocity.

2. Which interview topics best reveal TypeScript strength?

• Deep dives into generics, structural typing, discriminated unions, async control flow, module boundaries, testing strategy, and typing third‑party libs.

3. Which tools support remote TypeScript assessments and interviews?

• Code collaboration (GitHub), live coding (CoderPad), structured testing (CodeSignal), video (Zoom), and whiteboarding (Miro) form a robust toolkit.

4. How can cultural fit be evaluated for distributed TypeScript teams?

• Assess async writing samples, documentation habits, feedback style, prior remote examples, timezone coordination, and ownership mindset.

5. Which mistakes frequently derail TypeScript remote recruitment?

• Vague role scopes, framework-agnostic tests, marathon take‑homes, unclear compensation bands, and slow feedback cycles drive candidate drop‑off.

6. How should a take‑home assignment be structured?

• Realistic scope (2–4 hours), clear requirements, public repo submission, rubric grading, optional extension goals, and timely debriefs keep it fair.

7. Which compensation benchmarks guide offers for remote TypeScript roles?

• Use reliable market data by region and seniority, factor total rewards (benefits, equity), and calibrate for frameworks, cloud, and leadership scope.

8. How do we secure IP when engaging remote contractors?

• Execute NDAs and invention assignment, restrict repository access by least privilege, define code ownership, and include work‑for‑hire language.

Sources

• https://www.mckinsey.com/featured-insights/sustainable-inclusive-growth/americans-are-embracing-flexible-work-and-they-want-more-of-it
• https://www.pwc.com/us/en/library/covid-19/us-remote-work-survey.html
• https://www.statista.com/statistics/215394/number-of-software-developers-worldwide/