$On recrute · Senior Dev Full-Stack

Tu codes la machine qui automatise les ventes des PME québécoises.

Stack opinionated. Multi-tenant strict avec RLS qui isole chaque PME au niveau row. Twilio, Stripe Connect et Resend orchestrés par 130+ edge functions en production. On cherche un autre senior dev pour shipper plus vite — pas un sauveur.

// Stack en production

Next.js 16SupabaseTypeScript strictTwilioStripe ConnectResendClaude CodeTailwind v4

Voir le poste

100 % remote · Québec

system-status.ts

Production · en direct

$

edge functions Deno en production

intégrations OAuth orchestrées

canaux d'acquisition de leads

// Propulsé par

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 });

});

Pourquoi Capturia

Le produit roule. Les clients paient. L'équipe est compétente. On a juste besoin de plus de capacité pour shipper plus vite. C'est pour ça qu'on cherche un autre senior dev.

Dany Therrien

Fondateur, Capturia

01
Un produit qui roule.
Pas un prototype.
130+ edge functions en prod, des intégrations OAuth, des workflows automatisés, des clients qui paient chaque mois. Tu arrives pas dans un greenfield — tu arrives dans quelque chose qui tourne déjà.
02
Tu codes. Tu reviewes. Tu shippes.
Pas de Jira. Pas de PM.
Pas de sprint planning à 12 personnes. Tu pickes une PR, tu fais le code, l'équipe review, ça merge sur develop. Staging déploie. Tu vois ton code dans le produit avant la fin de la journée.
03
Le fondateur est à un message.
Réponse direct au DM.
Une question? DM direct au fondateur. La réponse arrive vite. Pas de couches d'intermédiaires entre toi et les décisions produit.

Le système en marche

Du message entrant au booking confirmé, en temps réel.

C'est le flow que tu vas coder. Webhooks Twilio, edge functions Deno, RLS multi-tenant, realtime sync, TanStack Query invalidate. Tout est observable au push — pas de boîte noire.

step-01.ts

// Étape 01

Lead Instagram

Le prospect écrit dans la DM

edge-fn:instagram-webhook

HMAC signature · RLS multi-tenant context resolve

step-02.ts

// Étape 02

Agent IA répond

Conversation qualifiée en quelques secondes

Claude stream · chat_messages INSERT

trigger sync vers unified_threads

step-03.ts

// Étape 03

Booking confirmé

RDV créé sans intervention humaine

supabase realtime · TanStack invalidate

calendar slot lock · Zoom auto-provisioned

step-04.ts

// Étape 04

Call analysé

Température lead recalculée auto

AssemblyAI webhook · classifier IA

lead.temperature update · IntelliSuivi triggered

Une journée

Du vrai travail de dev, pas de meetings interminables.

Pas de standup inutile, pas de sprint planning à 12 personnes. Tu prends une tâche, tu fais le travail, tu shippes.

[09:00:00INFO]boot.check
Vérifier que tout tourne
15 min
Tu regardes Vercel, les logs Supabase, les dashboards. Si quelque chose a planté, tu le vois toi-même.
[09:30:00INFO]code.read
Lire le code, comprendre les impacts
2 h focus
Tu lis le code existant, tu identifies les impacts de ce que tu vas faire. Après ça seulement, tu commences à coder.
[11:30:00OK]db.migrate
Migrations + backend
2 h
Migrations MCP, politiques RLS, structure de données. Tu prends ces décisions-là sans demander la permission.
[14:00:00INFO]review.code
Review de code
1 h
Tu reviews le code de l'équipe et l'équipe review le tien. Pas juste ce qui est wrong — pourquoi c'est wrong et comment faire mieux.
[15:30:00INFO]ship.validate
Validate + ship
30 min
npm run validate. Zéro warning. Tu pushes en production en sachant exactement ce que tu livres.
[16:30:00OK]sync.founder
Sync avec le fondateur
10 min
C'est pas une réunion formelle. Trois messages pour s'aligner sur la prochaine priorité et c'est réglé.

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 });

});

L'équipe

Avec qui tu vas coder

L'équipe technique en place, full-stack, tous solides.

TypeScript strict, code reviews honnêtes, pair programming quand c'est complexe.
On code pas en silos. On débat les choix techniques entre pairs.
Personne arrive en mode « je vais vous montrer comment faire ». Personne arrive en mode « j'attends qu'on me dise quoi faire ».
Une équipe de devs solides qui shippent ensemble. C'est tout.

Le filtre

5 indispensables. 5 red flags. Sois honnête avec toi-même.

On préfère filtrer ici plutôt que perdre 6 mois ensemble. Si tu te reconnais dans 4 ou 5 indispensables, on veut te parler.

Indispensable

REQ-001
5+ ans de full-stack en production
Tu as livré et maintenu une codebase en production, pas juste contribué à un side project. React/Next + backend solide. Tu sais ce que veut dire vivre avec son propre code.
REQ-002
Ownership d'une codebase existante
Tu sais prendre du code que t'as pas écrit, le lire, comprendre les patterns, et faire des choix cohérents. Pas juste fermer des tickets.
REQ-003
TypeScript strict, vraiment strict
Aucun any toléré. Interfaces, génériques, types explicites. Tu sais pourquoi le type system existe et tu l'utilises.
REQ-004
PostgreSQL pour vrai
Migrations versionnées, contraintes, RLS, indexes. Tu sais lire un EXPLAIN ANALYZE et fix une query N+1.
REQ-005
Discussion technique d'égal à égal
Ni passif, ni dominateur. Tu défends tes choix avec arguments, tu changes d'idée quand un argument est meilleur.

Les red flags

FLAG-001
Tu livres du code sans lire ce qui existe déjà.
FLAG-002
Tu prends des décisions sans évaluer l'impact en production.
FLAG-003
T'attends qu'on te dise quoi faire au lieu d'initier.
FLAG-004
Aucun pattern consistant — chaque problème, tu repars de zéro.
FLAG-005
Tu arrives en pensant « je vais leur montrer ». L'équipe sait déjà — on cherche un partenaire, pas un sauveur.

Atouts en plus

BONUS-001
Supabase en profondeur
Auth, RLS, Edge Functions Deno, Realtime. Tu sais quand utiliser quoi.
BONUS-002
OAuth complexe
Zoom, Google, Stripe Connect. Tu as déjà debug une callback URL qui foire à 2 h du matin.
BONUS-003
SaaS multi-tenant en prod
Des vrais clients qui paient. Pas juste un side project.
BONUS-004
Mentorer / reviewer d'autres devs
Tu as déjà guidé du code review. Pas comme un boss — comme un peer.

Candidature

Ça t'parle?

100% remote, basé au Québec.

Tu codes la machine qui automatise les ventes des PME québécoises.

Un produit qui roule.

Tu codes. Tu reviewes. Tu shippes.

Le fondateur est à un message.

Du message entrant au booking confirmé, en temps réel.

Lead Instagram

Agent IA répond

Booking confirmé

Call analysé

Du vrai travail de dev, pas de meetings interminables.

Vérifier que tout tourne

Lire le code, comprendre les impacts

Migrations + backend

Review de code

Validate + ship

Sync avec le fondateur

Avec qui tu vas coder

5 indispensables. 5 red flags. Sois honnête avec toi-même.

5+ ans de full-stack en production

Ownership d'une codebase existante

TypeScript strict, vraiment strict

PostgreSQL pour vrai

Discussion technique d'égal à égal

Supabase en profondeur

OAuth complexe

SaaS multi-tenant en prod

Mentorer / reviewer d'autres devs

Ça t'parle?