Does your product need access to your customers' data? Maybe their CRM, HRIS, or cloud storage? Have you already built a few integrations by hand — and felt the real cost? Are your engineers spending time on pagination, retry logic, and high volume sync pipelines at the expense of improving your core product?
If that sounds familiar, we should talk.
Let's talkYour AI needs full context across your customers' tools. Your customers expect their data to just be there. And your engineers are spending a third of their time on integration maintenance instead of your core product.
Salesforce throttles differently than HubSpot. HubSpot differently than Jira. You're building bespoke retry logic for every API — and when you get it wrong, your customers' data goes stale.
The same contact comes back across pages, endpoints, and incremental windows. At 50 customers syncing daily, duplicate records silently corrupt your customers' data.
A sync fails and you don't know until a customer opens a ticket. You need to see every object, every HTTP request, every run — not just a status dot on a dashboard.
A pilot with 500 records is easy. Hundreds of customers with 500k objects each is a different problem — pagination, backpressure, memory, and timeouts you never planned for.
Lightyear gives you the infrastructure to build, deploy, and monitor sync integrations — fast.
Start with an AI prompt or write it yourself. OAuth config, REST connectors, data mapping, sync logic — it's all TypeScript in your IDE, version-controlled and reviewable.
The dev server watches for changes and deploys instantly to your dev environment. When you're ready, push to production with a single command — or wire it into your CI pipeline.
Your customers connect their own accounts via a simple authorize flow. Lightyear handles token storage, refresh, and per-tenant settings — you just drop a button on your integrations page.
A baseline sync kicks off automatically. From there, incremental syncs poll on a schedule, with full syncs less frequently to catch anything that slipped through.
Source data is synced and normalized as objects across your collections. Pull from Lightyear, push to your existing API, or query directly — however your product needs it.
In production, things break. With Lightyear, you see exactly what happened — every object, every HTTP request, every run. Diagnose fast, fix fast.
Lightyear runs on serverless infrastructure that scales with your customer base. Hundreds of tenants, millions of objects — no capacity planning on your side.
// Define a complete HubSpot OAuth integration import { createOAuthConnector, defineCustomApp } from "@runlightyear/sdk"; const hubspotOAuth = createOAuthConnector() .withAuthUrl("https://app.hubspot.com/oauth/authorize") .withTokenUrl("https://api.hubapi.com/oauth/v1/token") .withScope([ "crm.objects.contacts.read", "crm.objects.deals.read", "crm.objects.deals.write", // ...add whatever scopes you need ]) .build(); export const hubspot = defineCustomApp("hubspot", "OAUTH2") .withTitle("HubSpot") .withOAuthConnector(hubspotOAuth) .addVariable("appId") .deploy();
// Make authenticated API calls — tokens handled automatically import { createRestConnector } from "@runlightyear/sdk"; export const hubspotRest = createRestConnector() .withBaseUrl("https://api.hubapi.com/crm/v3") .addHeader("Authorization", "Bearer {{ auth.accessToken }}") .build();
// Define how data flows in and out of HubSpot import { createSyncConnector } from "@runlightyear/sdk"; export const hubspotSync = createSyncConnector(hubspotRest, crmCollection) .withModelConnector("contact", (m) => m.withList({ request: ({ cursor }) => ({ endpoint: "/objects/contacts", method: "GET", params: { limit: 100, after: cursor }, }), responseSchema: z.object({ /* ... */ }), transform: (res) => res.results.map((r) => ({ externalId: r.id, data: { firstName: r.properties.firstname, lastName: r.properties.lastname, email: r.properties.email, }, })), pagination: ({ response }) => ({ hasMore: !!response.paging?.next?.after, cursor: response.paging?.next?.after ?? null, }), }) .withBatchCreate({ /* ... */ }) .withBatchUpdate({ /* ... */ }) .withBatchDelete({ /* ... */ }) ) // Repeat for account, opportunity, note... .build();
// Wire it all together into a complete integration import { defineIntegration, defineAction } from "@runlightyear/sdk"; defineIntegration("hubspot-crm") .withTitle("HubSpot CRM") .withCustomApp(hubspotCustomApp) .withCollection(crmCollection) .withDescription("Sync HubSpot CRM data to Sales Sidekick") .withSyncSchedules({ baseline: { maxRetries: 3 }, incremental: { every: "1 minutes" }, full: { every: "24 hours" }, }) .withActions( defineAction("hubspot-full-sync") .withType("FULL_SYNC") .withRun(async () => { await hubspotSyncConnector.sync("FULL"); }) .deploy(), defineAction("hubspot-incremental-sync") .withType("INCREMENTAL_SYNC") .withRun(async () => { await hubspotSyncConnector.sync("INCREMENTAL"); }) .deploy(), ) .deploy();
No pre-built catalog to outgrow. Define a Custom App for any API your customers use — OAuth config, REST connector, sync logic — and deploy it in a single session.
We're working closely with a small group of early teams and have the bandwidth to go deep. If any of this resonated, we'd love to hear what you're up against.
Book a call