$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 16SupabaseTypeScript strictTwilioStripe 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 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 PR, you write the code, the team reviews, it merges to develop. Staging deploys. You see your code in production before the end of the day.
03
The founder is one message away.
Reply straight to your DM.
A question? Direct DM to the founder. The answer lands 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, realtime sync, TanStack Query invalidate. Everything observable at push — no black box.

step-01.ts

// Step 01

Instagram lead

Prospect writes in the DM

edge-fn:instagram-webhook

HMAC signature · multi-tenant RLS context resolve

step-02.ts

// Step 02

AI agent replies

Conversation qualified in seconds

Claude stream · chat_messages INSERT

trigger sync to unified_threads

step-03.ts

// Step 03

Booking confirmed

Meeting created without human intervention

supabase realtime · TanStack invalidate

calendar slot lock · Zoom auto-provisioned

step-04.ts

// Step 04

Call analyzed

Lead temperature recomputed automatically

Fireflies 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:00INFO]boot.check
Check everything's running
15 min
You check Vercel, Supabase logs, dashboards. If something broke, you see it yourself.
[09:30:00INFO]code.read
Read the code, map the impacts
2h focus
You read the existing code, identify the impacts of what you're about to do. Only then do you start coding.
[11:30:00OK]db.migrate
Migrations + backend
2h
MCP migrations, RLS policies, data structure. You make these decisions without asking permission.
[14:00:00INFO]review.code
Code review
1h
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:00INFO]ship.validate
Validate + ship
30 min
npm run validate. Zero warnings. You push to production knowing exactly what you're shipping.
[16:30:00OK]sync.founder
Sync with the founder
10 min
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, all solid.

Strict TypeScript, honest code reviews, pair programming when it's complex.
We don't code in silos. We debate technical choices between 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.

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
TypeScript strict, 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 saviour.

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 already debugged a broken callback URL at 2am.
BONUS-003
Multi-tenant SaaS in production
Real paying clients. Not just a side project.
BONUS-004
Mentor / review other devs
You've guided code review before. Not like a boss — like a peer.

Application

Sound like you?

100% remote, based in Quebec.

You build the machine that automates sales for Quebec SMBs.

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

TypeScript strict, really strict

Real PostgreSQL

Technical discussion as equals

Supabase in depth

Complex OAuth

Multi-tenant SaaS in production

Mentor / review other devs

Sound like you?