What 90% of companies do wrong: They schedule a video call as the first step.

What we do instead: We send a detailed project brief and ask 3 questions via email.

Example brief (for a React position):

Project: You're building a dashboard for tracking developer productivity.

Requirements:

• Users can see commits, PRs, and code reviews by day/week/month
• Filter by team member
• Export data as CSV
• Must load in under 2 seconds with 100k data points

Questions:

1. How would you structure the component hierarchy?
2. What performance optimizations would you implement?
3. What edge cases would you test for?

Please respond within 24 hours with your answers (aim for 200-400 words total).

What we're testing:

• Do they respond within 24 hours? (reliability)
• Are answers clear and structured? (communication)
• Do they ask clarifying questions? (critical thinking)
• Do they reference specific libraries/patterns? (technical knowledge)

Pass criteria:

• Responds in < 24 hours: +10 points
• Clear, structured answers: +10 points
• Asks 1-2 clarifying questions: +5 points
• References specific tech (e.g., React Query, virtualization): +5 points

Fail immediately if:

• ❌ Takes > 48 hours to respond (unreliable)
• ❌ One-sentence answers (poor communication)
• ❌ Copy-pasted ChatGPT responses (obvious)

Result: This 10-minute async test eliminates 40% of candidates before we spend any interview time.

What 90% of companies do wrong: LeetCode-style algorithm questions.

What we do instead: Real-world coding that matches our actual work.

Format: Live coding session (they share screen, we observe)

Project: Small feature that mimics real work

Example for frontend developer:

Task: Build a paginated, filterable user table

Requirements:

• Fetch from API: https://jsonplaceholder.typicode.com/users
• Table columns: Name, Email, Company, City
• Filter by city (dropdown)
• Pagination (10 per page)
• Loading and error states

Time: 60 minutes Stack: React + your choice of libraries

What we're evaluating:

Scoring rubric:

Red flags that auto-fail:

• ❌ Can't get basic functionality working in 90 minutes
• ❌ Doesn't handle loading/error states at all
• ❌ Can't explain their own code when asked
• ❌ Googles every single syntax question (some is fine, constant is not)

Green flags that boost score:

• ✅ Asks about browser compatibility upfront
• ✅ Mentions accessibility (ARIA labels, keyboard nav)
• ✅ Writes a few tests or mentions testing strategy
• ✅ Commits code incrementally (shows thinking process)

Task: Build a REST API for a todo app

Requirements:

• CRUD operations for todos (title, description, completed, userId)
• Authentication (simple JWT)
• Input validation
• User can only access their own todos

Time: 75 minutes Stack: Node + Express (or your preferred backend framework)

Evaluation criteria:

• API design (RESTful routes, proper HTTP methods)
• Security (authentication, authorization, input validation)
• Error handling (proper status codes, error messages)
• Database schema (normalization, indexes)
• Code organization (routes, controllers, middleware)

What 90% of companies do wrong: Either skip this entirely OR assign huge take-home projects (8+ hours).

What we do instead: 2-3 hour take-home with deliberately vague requirements.

Why vague requirements? Remote developers constantly face ambiguity. We need to see if they:

• Make reasonable assumptions
• Ask clarifying questions
• Document their decisions

Project: Build a GitHub repository search tool

Core requirement: User enters a search term, sees list of repositories

Deliverables:

• Working application (hosted link or local setup instructions)
• README explaining your approach
• 2-3 sentences on what you'd improve with more time

Time limit: 2-3 hours (we trust you to track honestly)

Deliberately vague elements:

• How many results to show?
• What info to display for each repo?
• Pagination or infinite scroll?
• Error handling for rate limits?
• TypeScript or JavaScript?

What we're looking for:

Documentation quality (50% of score):

Example README structure:

# GitHub Repo Search

## Approach
- Used GitHub REST API v3
- Limited results to 30 (API default)
- Implemented debounced search (500ms) to reduce API calls
- Stored recent searches in localStorage

## Trade-offs
- Chose REST over GraphQL for simplicity
- Skipped advanced filters due to time constraint
- Would add: user authentication, saved searches, dark mode

## Running locally
npm install && npm start

Code quality (30% of score):

• Clean component structure
• Proper error handling
• Reasonable UI/UX decisions

Communication (20% of score):

• Did they email us questions during the project?
• Did they explain assumptions in README?
• Did they admit what they'd improve?

Red flags:

• ❌ Takes 10+ hours (can't scope work)
• ❌ Zero documentation (poor communication)
• ❌ Implements every possible feature (can't prioritize)
• ❌ Doesn't ask ANY questions (doesn't seek clarity)

Green flags:

• ✅ Asks 1-3 clarifying questions via email
• ✅ Commits show incremental progress
• ✅ README explains trade-offs
• ✅ Completed in stated time (respects boundaries)

What 90% of companies do wrong: Managers interview alone.

What we do instead: 2-3 team members join (including potential peers).

Structure (45 minutes total):

Part 1: Project Walkthrough (15 min)

• Candidate presents take-home project
• We ask questions about decisions
• Candidate shares screen, navigates code

What we're evaluating:

• Can they explain technical decisions to peers?
• How do they handle questions/pushback?
• Do they take ownership of mistakes?

Part 2: Scenario Questions (20 min)

We ask about realistic remote work scenarios:

Scenario 1: Communication

"You're stuck on a bug for 3 hours. You've Googled, read docs, and tried 5 different approaches. What do you do?"

Good answers:

• "I'd write up what I've tried so far and post in team Slack with specific error messages"
• "I'd look for similar code in our codebase to see how it was solved before"
• "I'd ask for a 15-minute pair programming session with someone who knows this area"

Bad answers:

• "I'd keep trying until I figure it out" (doesn't know when to ask for help)
• "I'd ask my manager" (doesn't try to self-solve)

Scenario 2: Async Collaboration

"Your feature is blocked waiting for a backend API from a teammate in a different timezone. The API was supposed to be done yesterday. What do you do?"

Good answers:

• "I'd check the PR/branch to see current progress"
• "I'd message them with a specific question about ETA and if I can help"
• "I'd mock the API response and continue frontend work in parallel"

Bad answers:

• "I'd wait for them to finish" (not proactive)
• "I'd escalate to manager immediately" (doesn't try direct communication first)

Scenario 3: Self-Direction

"You finish your assigned work 2 days early. Your manager is on vacation. What do you do with the extra time?"

Good answers:

• "I'd look at the backlog for the next priority ticket and start on that"
• "I'd write tests for the feature I just shipped"
• "I'd tackle some tech debt or refactoring I've been wanting to do"
• "I'd update documentation for recent changes"

Bad answers:

• "I'd wait for my manager to get back and assign me something" (not self-directed)
• "I'd work on my personal side project" (not invested in company)

Part 3: Team Member Q&A (10 min)

Team members ask their own questions:

• "What's your ideal code review feedback style?"
• "How do you prefer to receive critical feedback?"
• "Tell me about a time you disagreed with a technical decision. What happened?"

Final team vote: Each team member answers: Would you want to work with this person?

• Must be 75%+ yes to proceed

What 90% of companies do wrong: Call references and ask "Was this person good?"

What we do instead: Ask specific behavioral questions about remote work habits.

Our reference check questions:

For communication:

"On a scale of 1-10, how would you rate [candidate]'s written communication? Can you give a specific example of a time they communicated really well or really poorly in writing?"

For self-direction:

"How often did [candidate] need clarification or guidance on tasks? Can you give an example of a time they figured something out on their own vs a time they needed help?"

For reliability:

"Did [candidate] meet deadlines consistently? If they were going to miss a deadline, how did they communicate that?"

For collaboration:

"How did [candidate] handle code review feedback? Can you describe a specific instance?"

Red flags in references:

• Vague answers ("they were fine")
• Can't give specific examples
• Damning with faint praise ("they showed up on time")

Green flags:

• Specific examples of good behavior
• Reference says "I'd hire them again immediately"
• Reference asks if they can reconnect with candidate

What companies do:

• Ask brain teasers
• Require optimizing algorithms to O(n log n)
• Test CS theory from 10 years ago

Why it's wrong: You don't need brilliant developers. You need reliable, communicative, self-directed developers who can ship features.

What to do instead:

• Test for real-world skills your team uses daily
• Value clear code over clever code
• Assess communication as heavily as technical ability

What companies do:

• Jump straight to synchronous video interviews

Why it's wrong: 60% of remote work is async (Slack, PRs, tickets, docs). If they can't write clear Slack messages, they'll be a bottleneck.

What to do instead:

• Test async communication first (email questions, take-home README)
• Evaluate PR description quality
• Ask for writing samples (blog, docs, Stack Overflow answers)

What companies do:

• Don't ask about working hours preferences
• Assume everyone will adjust to company timezone

Why it's wrong: Developers in Eastern Europe who agree to work US West Coast hours will burn out in 3-6 months.

What to do instead:

• Ask: "What hours do you prefer to work?"
• Ask: "How much timezone overlap do you need to be productive?"
• Hire people whose natural schedule overlaps 3-4 hours minimum

What companies do:

• Require "5+ years React experience"

Why it's wrong: A developer with 3 years of remote experience is often better than one with 8 years of in-office experience.

What to do instead:

• Focus on: Can they communicate? Can they self-direct? Can they ship?
• Weight remote work experience as heavily as technical experience
• Hire juniors with great communication over seniors who go silent

Minimum score: 70/100

Minimum score: 75/100

Minimum score: 70/100

Weighted total:

• Technical: 30% × score
• Communication: 40% × score
• Self-Direction: 30% × score

Example:

• Technical: 85/100 → 25.5 points
• Communication: 90/100 → 36 points
• Self-Direction: 75/100 → 22.5 points
• Total: 84/100

Hiring thresholds:

• 80-100: Strong hire (make offer)
• 70-79: Tentative (discuss with team)
• < 70: No hire

Override rules:

• If Communication score < 75: automatic no hire (can't succeed remotely)
• If Team interview votes < 75%: automatic no hire (culture fit issue)
• If Technical + Communication both > 85: strong hire regardless of total

• ❌ Takes > 48 hours to respond to emails during interview process
• ❌ Misses scheduled interview without advance notice
• ❌ Can't explain their own code in technical screen
• ❌ Take-home project has zero documentation
• ❌ Gives one-word answers in interviews

• ❌ Can't complete basic coding task in 90 minutes
• ❌ Copy-pastes code without understanding it
• ❌ Has never worked remotely before AND can't articulate how they'd adapt
• ❌ All experience is in outdated tech AND no evidence of learning new things

• ❌ Every scenario answer involves "asking manager"
• ❌ Take-home project took 15+ hours (can't scope work)
• ❌ Couldn't make ANY decisions in vague requirements without asking us
• ❌ References mention "needs lots of hand-holding"

• ❌ Speaks negatively about all past employers
• ❌ Blames teammates for every past project failure
• ❌ Team members vote < 50% yes
• ❌ Asks zero questions during entire process (not engaged)

Our survey of 200+ remote developers:

Surprised? Salary is #5, not #1. Remote developers value autonomy and flexibility over pure compensation.

Must-haves:

• Clear salary (don't lowball based on their location)
• Flexible working hours (not "9-5 your timezone")
• Home office stipend (€50-100/month or €1,500 one-time)
• Equipment (laptop, monitor, accessories)
• PTO policy (20+ days)

Nice-to-haves that win candidates:

• Professional development budget (€1,000/year)
• Conference attendance (1/year)
• Co-working space allowance
• Annual team meetup (bring whole team together)
• Internet backup plan (mobile hotspot for outages)