Senior Software Engineer - Distributed Systems & File Sync

Senior-level candidates are suitable for this role, with strong experience in distributed systems, file synchronization, cross-platform desktop applications, TypeScript, and SQL.

They should be skilled in designing scalable systems, writing and reviewing code, testing, infrastructure maintenance, performance optimization, troubleshooting, and defining engineering best practices.

The ideal candidate is familiar with owning complex technical tasks with limited supervision, collaborating cross-functionally, supporting macOS and Windows platforms, and mentoring junior engineers.

How would you design a reliable file synchronization protocol for a cross-platform desktop application?

I would model synchronization as a state-based protocol with explicit file metadata, version identifiers, operation logs, and idempotent updates. The design should support retries, resumable transfers, conflict detection, and platform-specific filesystem behavior on macOS and Windows.

How would you detect and resolve file conflicts when the same file is modified on multiple devices?

I would use version vectors or another causality-aware mechanism to detect concurrent updates rather than relying only on timestamps. Conflicts could be resolved through deterministic rules for some file types, while preserving conflicting versions or requesting user input when automatic merging is unsafe.

What consistency model would you choose for a distributed file-sync system, and why?

Eventual consistency is typically appropriate because devices may be offline and synchronization must remain available. I would provide stronger guarantees for individual operations such as atomic metadata updates, while using versioning and reconciliation to converge replicas.

How would you make synchronization operations idempotent and safe to retry?

Each operation should have a globally unique identifier and be recorded with its target version or content hash. The server and clients should recognize previously applied operations so network retries do not duplicate writes, deletes, or metadata changes.

How would you design a SQL schema for tracking file versions, sync states, and conflicts?

I would separate logical files, immutable file versions, device replicas, and synchronization operations into normalized tables with foreign keys and indexes on file identifiers, versions, and pending states. Transactions would protect state transitions, while retention policies would control the growth of historical versions and operation logs.

How would you handle large files and interrupted transfers efficiently?

I would split files into content-addressed chunks and transfer only missing or changed chunks. Transfers should support checksums, resumable offsets, bounded concurrency, backpressure, and cancellation so resource usage remains predictable across platforms.

What filesystem differences between macOS and Windows must be considered in a sync engine?

The implementation must account for path separators, case sensitivity, reserved names, Unicode normalization, symbolic links, file locking, permissions, and atomic rename behavior. It should also handle differing filesystem event semantics and normalize paths without losing the original user-visible names.

How would you prevent filesystem watcher events from causing synchronization loops?

I would associate locally generated writes with operation identifiers and maintain a short-lived record of expected events. Watcher events would be debounced, coalesced, and compared against known metadata or content hashes before being converted into new synchronization operations.

How would you diagnose and optimize poor synchronization performance?

I would instrument scan duration, event processing, database latency, network throughput, queue depth, chunk deduplication, and CPU or memory usage by platform. Profiling and controlled benchmarks would identify bottlenecks, after which I would optimize batching, indexing, concurrency limits, and unnecessary file or database work.

How would you test a distributed synchronization system implemented in TypeScript?

I would combine unit tests for conflict resolution and state transitions with integration tests using real SQL and simulated network failures. Property-based tests, deterministic event replay, multi-device scenarios, filesystem fixtures for macOS and Windows, and long-running stress tests would validate convergence and recovery behavior.

Air Labs Inc. is hiring a Senior Software Engineer to build robust, scalable synchronization features for its cross-platform desktop application. You’ll design and implement distributed systems, write tests, review code, maintain infrastructure, optimize performance across macOS and Windows, and mentor teammates using TypeScript and SQL. This is a primarily remote role for candidates in New York, with in-office attendance once a month or quarter as needed, offering a base salary of $280,000–$310,000 per year. Apply for the opportunity to solve challenging file-sync problems, shape engineering best practices, and make a meaningful impact with a highly competitive compensation package.