PartnersContact

Your product, from the first screen to the last backup.

Internal tools for your team and SaaS products for your customers, designed and built on one stack, with the AI and integrations that make them useful.

Start a projectSee what we build
Kestrel Plumbing · Ops
K
Kestrel Ops
  • Jobs
  • Customers
  • Quotes
  • Team
3 techs on the road
Jobs
Today · 5 open
  • #2041Blocked drainM. Okafor, GlebeSLOn site
  • #2040Hot water serviceRivera Dental, LeichhardtJTQuoted
  • #2039Leaking tapA. Chen, AnnandaleSLBooked
  • #2038Gas compliance checkHarbourview StrataMKWaiting on parts
  • #2037Gutter repairP. Nguyen, BalmainJTInvoiced

Blocked drain

#2041 · On site · M. Okafor, Glebe

Tech
Sam L.
Booked
9:30 am
  1. Booked from web form8:12 am
  2. Sam assigned8:20 am
  3. Arrived on site9:34 am
Message customer
Demo data
Internal tools, CRMs and portals: the system your staff run the business in.

Designed and engineered under one roof.

Spark Integrations is a Sydney technology company. The same people design the screen and the table it reads from, so neither one is a guess about the other.

Spark Integrations is led by founder Jack West.

We also build and operate our own SaaS product, Alony AI (opens in a new tab), a self-serve AI phone agent for Australian small businesses. Building and running it ourselves means we have already solved what a SaaS product runs into, layer by layer.

Custom internal tools for SMBs.

Off-the-shelf software makes you work its way. These are built around yours, and connected to the tools you already use.

  • Reporting dashboard

    Sales, jobs and cash in one view, pulled live from the tools you already use.

  • CRM

    Leads, clients and every conversation, shaped around how you actually sell.

  • Job and quote system

    From enquiry to quote to booked job to invoice, without retyping a thing.

  • Client portal

    Customers log in to see their jobs, documents and invoices, and pay online.

  • Rostering and scheduling

    Shifts and appointments built around who is free, qualified and nearby.

  • Inventory and stock

    Stock levels, reorders and supplier orders, tracked across every site.

  • Approvals

    Leave, purchases and quotes routed to the right person, with a record of who said yes.

  • Checklists and site forms

    Inspections, safety checks and sign-offs done on a phone and filed against the job.

Four layers, one team.

One team owns all four layers, so a change to a screen, a rule or a data model does not wait on a hand-off between a front-end agency and a back-end contractor.

  1. What your customers use

    The screens and voices people actually meet.

    • Web appOne codebase for desktop and phone, installs on the home screen from the browser, with no App Store needed.
    • Admin consoleWhere your team runs the product: customers, plans, support and settings.
    • Voice and chatAI phone agents and an in-app assistant that answer for the product, day and night.

  2. Logic and automation

    The rules that decide what happens when someone acts.

    • API and server codeEvery action is checked on the server before anything changes, never trusted from the browser.
    • Workflows and integrationsScheduled jobs and webhooks, and the links that keep your CRM, calendar and mail in step.
    • AI agentsSummarise, draft and report inside the product, using your own data.

  3. Data, identity and billing

    Who your customers are, what they own and what they pay for.

    • Postgres databaseOn Supabase and Postgres, each customer's data is kept apart by row-level rules in the database itself.
    • Auth and rolesLogin, single sign-on, a second factor and roles that decide who sees what.
    • BillingPlans, trials and a customer portal, on Stripe or any billing platform with an API.

  4. Hosting and operations

    Where it runs, and how it stays up.

    • Flexible hostingVercel and Supabase by default, an Australian region where needed, or your own cloud.
    • Monitoring and backupsErrors reported as they happen, and point-in-time recovery for the database on Supabase.
    • ReleasesEvery change is tracked in Git, reviewed, tested and deployed to its own preview link before it reaches production.

The front end: laid out for every screen.

Every screen we build is laid out for desktop, laptop and phone, so nobody has to pinch and zoom, and it carries your brand on each one.

Spark Studio contacts view on a desktop screen, with fictional data
Alony call history on a laptop, with fictional data
Fictional data

Your colours and type, held consistent on every screen. Here are the palettes of two products we built.

  • Spark Studio
  • Alony

The back end: data designed before a single screen.

Good software starts with a good data model. Scroll to watch one take shape for a field-service app. Every action is validated on the server, and every customer's records are kept apart in the database itself.

  1. Data model
  2. Relations
  3. Tenant isolation
  4. Indexes and migrations
  5. Functions and API
Demo data: a field-service app

Data model. We map your business into tables first: what a customer, a job and a booking are, and which facts each one owns.

Relations. Primary and foreign keys tie the tables together, and constraints stop bad data at the door: no booking without a job, no orphaned invoice.

Tenant isolation. Every row carries its workspace. On Supabase, row-level security policies in Postgres keep each workspace to its own rows.

Indexes and migrations. Indexes keep the lookups you run most fast as the data grows. Every schema change is a versioned migration, reviewed and replayable.

Functions and API. Server functions validate every input before they write, and the same logic is exposed as a clean, versioned REST API.

Whether it's small internal software or large SaaS production, we can hold the architecture and infrastructure.

A database diagram for a field-service app on demo data. Six tables, workspaces, users, customers, jobs, invoices and bookings, are linked by primary and foreign keys. Every table carries a workspace_id, and row-level security hides other workspaces' rows. Indexes sit on customer_id, email and starts_at, and four versioned migrations build the schema. A server function, Create booking, validates input, checks access, writes in one transaction and sends a confirmation, and the REST API exposes bookings, customers and invoices under version 1.

Your software, as a clean API.

We give the software we build a clean REST API, so it can talk back and forth with your other tools in formats that are easy to diagnose.

Demo data
Request logEvery call, with its status, timing and request id
  1. 201 CreatedPOST /v1/customers48 msFrom CRM · 09:41:02 · req_4f1c
  2. 422 UnprocessablePOST /v1/bookings9 msFrom Booking form · 09:41:05 · req_4f2astarts_at must be in the future
  3. 201 CreatedPOST /v1/bookings61 msFrom Booking form · 09:41:11 · req_4f2d
  4. 200 OKbooking.created112 msTo Team chat · 09:41:11 · evt_91b0
  5. 201 CreatedPOST /invoices230 msTo Accounting · 09:41:12 · req_77e4
  6. 200 OKPOST /v1/webhooks/payments37 msFrom Payments · 09:42:40 · req_4f3b
  7. 404 Not FoundGET /v1/bookings/bkg_9z1x6 msFrom AI assistant · 09:43:09 · req_4f3eno booking with id bkg_9z1x
  8. 200 OKGET /v1/bookings?date=today34 msFrom AI assistant · 09:43:15 · req_4f40

A demo, on demo data, of software talking to six other tools through its REST API. A CRM creates a customer. A booking form sends a time in the past and is refused with the reason, starts_at must be in the future, then succeeds when sent again. The software posts a booking event to team chat and raises an invoice in accounting software, a payment platform reports a deposit, an AI assistant asks for a booking that does not exist and gets a 404 naming the id, then reads today's bookings with the same login and roles as the app. Each call is logged with its status, timing and request id.

What actually goes into a SaaS product.

A SaaS product is more than its screens. These are the parts underneath that decide whether it holds up with real customers, and we plan for every one of them from the first day.

  • Multi-tenant data model

    Every customer's records live in one database kept apart by rules in the database itself.

  • Auth, roles and SSO

    Email and password or single sign-on, a second factor, and roles that decide who can see and change what.

  • Billing and entitlements

    Plans, trials, upgrades and cancellation, with each plan switching features and limits on and off in the product.

Onboarding
Sign-up and a guided setup, so new customers get going on their own.
Admin console
Where your team manages customers, plans, support and settings without asking a developer.
Audit logs
A record of who did what and when, for your support team and for customers who ask.
Background jobs
Imports, reports, reminders and syncs that run on their own, on a schedule.
Observability and alerting
Errors, slow pages and failed jobs reported as they happen, so problems are fixed before customers notice.
Encryption
On our default Vercel and Supabase stack, data is encrypted in transit (TLS 1.2+) and at rest (AES-256).
Backups and point-in-time recovery
On Supabase, the database can be restored to any moment in its recovery window, not just last night.
Rate limiting and abuse protection
Caps on how often each endpoint can be called, so a bad actor or a runaway script cannot take the product down.
Environments and preview deploys
Development, preview and production kept apart, and every change deployed to its own link before it goes live.
CI and tests
Automated tests run on every change, and nothing reaches production without passing them.

The stack we build on.

We use one proven stack across our own products and client builds, so there is no bespoke framework to maintain.

  • Web and mobile UI

    Next.js and Vite (React, TypeScript) with Tailwind CSS, shadcn/ui and Radix UI components, installable as a progressive web app

    One codebase for desktop, phone and tablet; fast first load; installs on the home screen straight from the browser, with no App Store needed

  • API and server logic

    Next.js server functions and API routes on Node.js, and Deno (Supabase Edge Functions) for small functions that run close to your users

    Server code sits beside the UI it serves; on Vercel and Supabase it scales to zero when idle

  • Database

    We build on Supabase, Convex, Neon or a managed Postgres service in your own cloud, such as Amazon RDS or Azure Database for PostgreSQL, whichever fits the product. On Supabase, Postgres with row-level security.

    On Supabase and Postgres: per-tenant data isolation enforced in the database, not just the app, and on Supabase, point-in-time recovery

  • Auth and roles

    Supabase Auth by default, or Clerk or Auth0: email and password, an optional second factor, SSO where your customers need it (SAML or OIDC, through Microsoft Entra ID, Google Workspace or Okta), and role-based access

    Owner, member and customer roles out of the box; sessions verified locally for speed

  • Billing

    Stripe by default, or Paddle, Chargebee, Square or GoCardless, with invoices raised in Xero where your accounts already live. Any billing platform with a proper API works.

    Plans, trials, upgrades, failed-payment handling and self-serve cancellation

  • Hosting

    Flexible: Vercel for the app and Supabase for the database by default, in an Australian region where needed. We also deploy to Cloudflare Workers and Pages, Convex, or your own cloud on AWS or Azure.

    On Vercel and Supabase: deploy on every push, previews per branch, no servers to patch

  • Security

    On our default Vercel and Supabase stack, data is encrypted in transit (TLS 1.2+) and at rest (AES-256).

    Our default: every endpoint checks who is calling, every route is rate limited, every key is scoped to least privilege, secrets live in managed environment secrets and never in the code, sensitive actions are audit logged, and production runs apart from every other environment. We also work inside your own setup: your cloud, your identity provider and your security policies.

  • Automation

    We write automations in TypeScript that run on scheduled jobs and webhooks beside your app on Vercel and Supabase, with every run logged. Where n8n, Make or Zapier suits you better, we'll work in those too.

    Written, tested and deployed with the rest of the product, triggered by Vercel Cron schedules or webhooks, with state and every run logged in Supabase

  • AI

    We integrate the right model for each job: frontier LLMs from Anthropic, OpenAI, Google, Meta and Mistral, or local small language models where privacy or cost calls for it.

    Inside the product: agents that use your tools, classifying and routing what comes in, drafting replies and documents, research, reading documents and images, voice, summaries and extraction

  • Telephony

    Twilio, Telnyx and Dialpad, or the phone system you already use

    Real Australian numbers, inbound and outbound. Keep your number and phone system and forward calls to the agent, or take a new number

  • Voice AI

    Voice agents on ElevenLabs, Synthflow and Retell, or on Alony, our own phone agent product

    Natural-sounding phone agents that answer, book and follow up, inbound and outbound

  • Email and monitoring

    Transactional email from your own domain through Resend or Postmark, or through the Outlook and Gmail APIs when mail should come from a real inbox. Errors tracked in Sentry, with uptime checks on the endpoints that matter.

    Sign-in, receipt and notification email that lands in the inbox; errors reported with what we need to fix them, usually before your customers notice

  • Code and tests

    GitHub repositories, Vitest and Playwright

    Automated tests run on every change, and nothing reaches production without passing them

  • Integrations

    We work API-first: REST and GraphQL APIs, webhooks, oAuth 2.0 and API keys, jSON and JSON Schema, openAPI specs, clean REST APIs for the software we build, event-driven sync, idempotent retries, rate-limit handling, and data mapping and transformation.

    If a tool has an API, your product can talk to it, reliably and without anyone retyping. Every endpoint we open is guarded: webhook signatures verified, auth on every call, rate limits, and bot protection on public forms.

The stack we build on
LayerWhat we useWhy
Web and mobile UINext.js and Vite (React, TypeScript) with Tailwind CSS, shadcn/ui and Radix UI components, installable as a progressive web appOne codebase for desktop, phone and tablet; fast first load; installs on the home screen straight from the browser, with no App Store needed
API and server logicNext.js server functions and API routes on Node.js, and Deno (Supabase Edge Functions) for small functions that run close to your usersServer code sits beside the UI it serves; on Vercel and Supabase it scales to zero when idle
DatabaseWe build on Supabase, Convex, Neon or a managed Postgres service in your own cloud, such as Amazon RDS or Azure Database for PostgreSQL, whichever fits the product. On Supabase, Postgres with row-level security.On Supabase and Postgres: per-tenant data isolation enforced in the database, not just the app, and on Supabase, point-in-time recovery
Auth and rolesSupabase Auth by default, or Clerk or Auth0: email and password, an optional second factor, SSO where your customers need it (SAML or OIDC, through Microsoft Entra ID, Google Workspace or Okta), and role-based accessOwner, member and customer roles out of the box; sessions verified locally for speed
BillingStripe by default, or Paddle, Chargebee, Square or GoCardless, with invoices raised in Xero where your accounts already live. Any billing platform with a proper API works.Plans, trials, upgrades, failed-payment handling and self-serve cancellation
HostingFlexible: Vercel for the app and Supabase for the database by default, in an Australian region where needed. We also deploy to Cloudflare Workers and Pages, Convex, or your own cloud on AWS or Azure.On Vercel and Supabase: deploy on every push, previews per branch, no servers to patch
SecurityOn our default Vercel and Supabase stack, data is encrypted in transit (TLS 1.2+) and at rest (AES-256).Our default: every endpoint checks who is calling, every route is rate limited, every key is scoped to least privilege, secrets live in managed environment secrets and never in the code, sensitive actions are audit logged, and production runs apart from every other environment. We also work inside your own setup: your cloud, your identity provider and your security policies.
AutomationWe write automations in TypeScript that run on scheduled jobs and webhooks beside your app on Vercel and Supabase, with every run logged. Where n8n, Make or Zapier suits you better, we'll work in those too.Written, tested and deployed with the rest of the product, triggered by Vercel Cron schedules or webhooks, with state and every run logged in Supabase
AIWe integrate the right model for each job: frontier LLMs from Anthropic, OpenAI, Google, Meta and Mistral, or local small language models where privacy or cost calls for it.Inside the product: agents that use your tools, classifying and routing what comes in, drafting replies and documents, research, reading documents and images, voice, summaries and extraction
TelephonyTwilio, Telnyx and Dialpad, or the phone system you already useReal Australian numbers, inbound and outbound. Keep your number and phone system and forward calls to the agent, or take a new number
Voice AIVoice agents on ElevenLabs, Synthflow and Retell, or on Alony, our own phone agent productNatural-sounding phone agents that answer, book and follow up, inbound and outbound
Email and monitoringTransactional email from your own domain through Resend or Postmark, or through the Outlook and Gmail APIs when mail should come from a real inbox. Errors tracked in Sentry, with uptime checks on the endpoints that matter.Sign-in, receipt and notification email that lands in the inbox; errors reported with what we need to fix them, usually before your customers notice
Code and testsGitHub repositories, Vitest and PlaywrightAutomated tests run on every change, and nothing reaches production without passing them
IntegrationsWe work API-first:
  • REST and GraphQL APIs
  • Webhooks
  • OAuth 2.0 and API keys
  • JSON and JSON Schema
  • OpenAPI specs
  • Clean REST APIs for the software we build
  • Event-driven sync
  • Idempotent retries
  • Rate-limit handling
  • Data mapping and transformation
If a tool has an API, your product can talk to it, reliably and without anyone retyping. Every endpoint we open is guarded: webhook signatures verified, auth on every call, rate limits, and bot protection on public forms.

Software we run every day

Our own platform and our own SaaS product, both live today on the stack above.

Spark HQ, our own operations platform

Spark HQ is an internal web app and software automation logic for all of our business operations, on the same stack we build for clients. We use it every day.

Mission Control

Today's priorities, across every client.

1 of 6 modules, all on the same stack as client builds.

Alony AI, our own SaaS

A self-serve AI phone agent for small businesses, live at alony.ai. A customer signs up, builds a fully tailored agent with no technical input, gets a real Australian phone number, and takes inbound and outbound calls within minutes.

Every call is recorded, transcribed and summarised in a dashboard, and customers connect their own API, calendar, CRM or webhook without any technical ability at all. Billing, trials, plan changes and cancellation are all self-serve. A partner tier lets a reseller manage agents for its own clients from one account, fully white-labelled for partners.

We built and operate all of it: front end, back end, telephony, billing and support.

Visit alony.ai (opens in a new tab)

Questions we get asked

Where does our data live?
Wherever it needs to. By default on Vercel and Supabase, in an Australian region where you need it, or in your own cloud. On our default Supabase stack, each customer's data is isolated at the database level, encrypted in transit (TLS 1.2+) and at rest (AES-256), and backed up with point-in-time recovery.
Can it work with the systems we already use?
Almost always. We work API-first: REST and GraphQL, webhooks and OAuth. If a system has an API or sends webhooks, your product can read from it and write to it, with retries and rate limits handled properly. When we build your software, we give it a clean REST API, or whatever API structure your other tools need, so it plugs into anything.
Will it work on phones as well as desktop?
Yes. We design for phone and desktop from the start, from one codebase. The app installs from the browser like a native one, with no app store in the way.
Which AI models do you use?
The right one for each job. We integrate frontier LLMs from Anthropic, OpenAI, Google, Meta and Mistral, or local small language models where privacy or cost calls for it.

Related services

Let's build it.

Tell us what you need and we'll show you how we'd build it.

Start a project

Or email jack.west@sparkintegrations.com.au