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 custom 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. As you add customers, duplicate records silently corrupt their data.
A sync fails and you don't know until a customer opens a ticket. You need object-level detail, full HTTP logs, and a trace of each 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.
When something goes wrong in production, you need to know exactly what happened. Lightyear surfaces every object, every HTTP request, and a full trace of each run, so you can diagnose and fix it 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 we'll invest the time to go deep on your use case. If you're dealing with any of this, we'd love to hear what you're up against.
Book a call