Getting Started with Remote

Welcome to the Remote developer and builder platform. Remote is the global payroll and employment infrastructure layer. It owns the hard parts (compliance, payroll execution, employment primitives, and the underlying data/controls), and opens that infrastructure so companies and partners can build the HR and payroll experiences that fit their business, instead of being confined to a single UI.

Who This is For

Builders at customers: developers, ops engineers, RevOps, IT, and data teams who want to connect Remote to their stack or automate workflows.
Builders at partners: product + engineering teams building Remote Embedded experiences for their users.
Non-dev stakeholders (PM, solutions consulting, admins) who need a clear “what you can build” overview.

Choose Your Starting Path

Remote provides multiple entry points depending on your technical stack, goals, and how much custom development you want to handle.

Path A: Integration Hub

Select this path if you are a customer looking to optimize internal operations.


Best for:	Syncing worker data with internal HRIS/finance stack, automating operational handoffs, or using Remote as an automated source of truth.
Process:	Remote REST API, webhooks, OAuth / access token, Role-Based Access Controls (RBAC).
Outcome:	A reliable, secure integration that seamlessly evolves with your tech stack.

Path B: Remote Embedded

Select this path if you are a platform provider (ATS, HRIS, or fintech) looking to expand your core product offering.


Best for:	Offering native global employment and payroll capabilities directly inside your proprietary application interface.
Process:	Remote Embedded API, partner credentials, multi-tenant account linking patterns, and specialized co-support workflows.
Outcome:	A scalable, partner-grade feature set that your customers can adopt instantly without leaving your ecosystem.

Plan C: Remote Build

Select this path if you want to accelerate your development with dedicated experts.


Best for:	Engineering teams operating under aggressive deadlines, navigating complex multi-system workflows, or wanting to avoid brittle, custom-coded debt.
Process:	Joint architectural design reviews and implementation support directly from Remote’s core engineering organization.
Outcome:	You build on Remote faster while maintaining rock-solid architectural guardrails.

What You Can Build

Remote is an open infrastructure platform. Because your data isn't trapped behind a closed interface, you can build customized experiences across three main pillars:

Connect Remote to your stack:
- Sync employee and employment lifecycle data into your HRIS, data warehouse, or finance tooling
- Keep systems aligned on hiring, changes, approvals, and payroll-relevant attributes
- Reduce manual handoffs and rekeying across tools
Automate workflows:

Remote isn’t a closed system that forces every workflow through one interface. If your business needs a custom workflow, you can build it:
- Approvals routing
- Payroll-adjacent operational tasks
- Admin guardrails that match your org structure
Build "Headless" experiences:

If you want the Remote foundation, but not the default UI as the primary surface, you can build headless experiences that:
- Fit your internal tools and processes
- Provide opinionated UX for your admins/managers/employees
- Still rely on Remote’s infrastructure for correctness and compliance

Before You Start

Use the following requirements checklist to align your team and avoid common pitfalls that stall integrations.

🏢 Organizational prerequisites:

You know who owns the integration
You have a clear model for environments (sandbox vs production)
You have agreed on data ownership defining which system is source of truth per field

🔒 Security prerequisites:

You understand how authentication works
You map the integration to least-privilege access. Ensure you are only requesting specific API endpoints and utilizing explicit RBAC roles matching the system task.

🏗️ Build prerequisites:

You have an initial use case you can ship end-to-end
You have mapped out your first successful data lifecycle execution and know how your systems should respond to it.

Quick Start Flow

Define your first use case: Identify a high-value workflow you can fully deploy in under two weeks. Explicitly define what data boundaries exist between Remote and your external system.
Set Up Authentication: Generate an access token or configure your OAuth protocol credentials within the Remote Dashboard.
Call Your First Endpoint: Verify connection health by running a GET against our basic endpoints (e.g., retrieving company metadata), then implement your first single-resource write path.
Add Webhooks: Subscribe to event-driven webhooks to listen for remote updates, keeping external platforms accurately synchronized automatically.
Operationalize: Inject application logging and request retry logic. Create an official internal support ownership and triage escalation path.

🛠️ Implementing Remote Embedded Instead?
If you are configuring a native partner platform experience, ensure you request partner credentials, map out tenant onboarding flows, and clearly isolate user interaction layers (What your app automates vs. What the customer admin manually checks vs. What Remote handles behind the scenes).

When to Use Remote Build vs DIY

Use Remote Build when	Do It Yourself when
You need to ship quickly and can’t afford integration rework	Your engineering department has dedicated internal platform capacity.
The customer needs a bespoke workflow that must remain supportable	Your integration is straightforward
You want to extend Remote safely without creating custom code	You already have integration patterns (OAuth, webhooks, observability) in place

Next Steps

Head over to: