$Now hiring · Senior Full-Stack Dev

You build the machine that automates sales for Quebec SMBs.

Opinionated stack. Strict multi-tenant with RLS isolating every SMB at row level. Twilio, Stripe Connect and Resend orchestrated by 130+ edge functions in production. We're hiring another senior dev to ship faster — not a savior.

// Production stack

Next.js 16SupabaseStrict TypeScriptTwilioStripe ConnectResendClaude CodeTailwind v4

See the role

100% remote · Quebec

system-status.ts

Production · live

$

Deno edge functions in production

OAuth integrations orchestrated

lead acquisition channels

// Powered by

Twilio · Stripe Connect · Supabase · Resend · Vercel · Cloudflare R2

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

Why Capturia

The product runs. Clients are paying. The team is solid. We just need more capacity to ship faster. That's why we're looking for another senior dev.

Dany D. Therrien

Founder, Capturia

01
A product that runs.
Not a prototype.
130+ edge functions in production, OAuth integrations, automated workflows, paying customers every month. You're not landing in a greenfield — you're landing in something that already runs.
02
You code. You review. You ship.
No Jira. No PM.
No 12-person sprint planning. You pick up a task, you write the code, the team reviews it, it merges into develop. Staging deploys. You see your code in the product before the end of the day.
03
The founder is one message away.
Direct replies, by DM.
A question? DM the founder directly. The answer comes fast. No layers between you and the product decisions.

The system in motion

From inbound message to confirmed booking, in real time.

This is the flow you'll be coding: Twilio webhooks, Deno edge functions, multi-tenant RLS, real-time sync, TanStack Query invalidation. Everything is observable from the moment you push — no black box.

step-01.ts

// Step 01

Instagram lead

The prospect sends a DM

edge function · instagram-webhook

HMAC signature · tenant resolved by RLS

step-02.ts

// Step 02

AI agent replies

Conversation qualified in seconds

Claude stream · chat_messages INSERT

Postgres trigger · unified_threads sync

step-03.ts

// Step 03

Booking confirmed

Meeting created without human intervention

Supabase Realtime · TanStack invalidation

calendar slot lock · Zoom auto-provisioned

step-04.ts

// Step 04

Call analyzed

Lead temperature updated instantly

AssemblyAI webhook · AI classifier

lead.temperature update · IntelliSuivi triggered

A day

Real dev work, no endless meetings.

No pointless standups, no 12-person sprint planning. You pick up a task, you do the work, you ship.

[09:00:00 INFO] boot.check
15 min
Check everything's running
You check Vercel, Supabase logs, dashboards. If something broke, you see it yourself.
[09:30:00 INFO] code.read
2 hr focus
Read the code, map the impacts
You read the existing code, identify the impacts of what you're about to do. Only then do you start coding.
[11:30:00 OK] db.migrate
2 hr
Migrations + backend
MCP migrations, RLS policies, data structure. You make these decisions without asking permission.
[14:00:00 INFO] review.code
1 hr
Code review
You review the team's code and the team reviews yours. Not just what's wrong — why it's wrong and how to do it better.
[15:30:00 INFO] ship.validate
30 min
Validate + ship
npm run validate. Zero warnings. You push to production knowing exactly what you're shipping.
[16:30:00 OK] sync.founder
10 min
Sync with the founder
It's not a formal meeting. Three messages to align on the next priority and you're done.

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

export async function POST(req: NextRequest) {

const { leadId, stage } = await req.json();

const { data, error } = await supabase

.from("client_contacts")

.update({ pipeline_stage: stage })

.eq("id", leadId).select().single();

if (error) return apiError(error.code, 400);

await triggerWorkflow("stage_changed", data);

return apiSuccess(data);

}

-- supabase/migrations/tenant_isolation.sql

create policy "tenant_isolation" on client_contacts

for all using (

client_id = get_current_client_id()

or is_active_team_member()

);

export function useLeadPipeline(leadId: string) {

return useQuery({

queryKey: ["pipeline", leadId],

queryFn: () => fetchPipelineData(leadId),

staleTime: 60_000,

});

}

// supabase/functions/sms-inbound/index.ts

serve(async (req) => {

await requireTwilioSignature(req);

const { From, Body } = await parseTwilioForm(req);

await routeToAgent({ from: From, body: Body });

return new Response(null, { status: 204 });

});

The team

Who you'll be coding with.

The engineering team in place: full-stack devs, all solid.

Strict TypeScript, honest code reviews, pair programming when it's complex.
We don't code in silos. We debate technical choices as peers.
Nobody walks in saying “I'll show you how it's done.” Nobody walks in waiting to be told what to do.
A team of solid devs shipping together. That's it.

A team that ships. Solid devs, working as peers.

The filter

5 must-haves. 5 red flags. Be honest with yourself.

We'd rather filter here than lose 6 months together. If 4 or 5 must-haves describe you, we want to talk.

Required

REQ-001
5+ years of full-stack in production
You've shipped and maintained a codebase in production, not just contributed to a side project. React/Next + solid backend. You know what it means to live with your own code.
REQ-002
Ownership of an existing codebase
You can take code you didn't write, read it, understand the patterns, and make consistent choices. Not just close tickets.
REQ-003
Strict TypeScript, really strict
No any tolerated. Interfaces, generics, explicit types. You know why the type system exists and you use it.
REQ-004
Real PostgreSQL
Versioned migrations, constraints, RLS, indexes. You can read an EXPLAIN ANALYZE and fix an N+1 query.
REQ-005
Technical discussion as equals
Neither passive nor dominating. You defend your choices with arguments, you change your mind when an argument is better.

Red flags

FLAG-001
You ship code without reading what already exists.
FLAG-002
You make decisions without evaluating production impact.
FLAG-003
You wait to be told what to do instead of taking initiative.
FLAG-004
No consistent patterns — every problem, you start from scratch.
FLAG-005
You walk in thinking “I'll show them how it's done.” The team already knows — we want a partner, not a savior.

Bonus

BONUS-001
Supabase in depth
Auth, RLS, Deno Edge Functions, Realtime. You know when to use what.
BONUS-002
Complex OAuth
Zoom, Google, Stripe Connect. You've debugged a broken callback URL at 2 a.m.
BONUS-003
Multi-tenant SaaS in production
Real paying clients. Not just a side project.
BONUS-004
Mentoring and reviewing other devs
You've led code reviews before. Not as a boss — as a peer.

Application

Sound like you?

100% remote, based in Quebec.

You build the machine that automates sales for Quebec SMBs.

Why Capturia

A product that runs.

You code. You review. You ship.

The founder is one message away.

From inbound message to confirmed booking, in real time.

Instagram lead

AI agent replies

Booking confirmed

Call analyzed

Real dev work, no endless meetings.

Check everything's running

Read the code, map the impacts

Migrations + backend

Code review

Validate + ship

Sync with the founder

Who you'll be coding with.

5 must-haves. 5 red flags. Be honest with yourself.

5+ years of full-stack in production

Ownership of an existing codebase

Strict TypeScript, really strict

Real PostgreSQL

Technical discussion as equals

Supabase in depth

Complex OAuth

Multi-tenant SaaS in production

Mentoring and reviewing other devs

Sound like you?