$On recrute · Senior Dev Full-Stack

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

Des choix techniques assumés. Une architecture multilocataire stricte, où la RLS isole chaque PME ligne par ligne. Twilio, Stripe Connect et Resend orchestrés par plus de 130 fonctions Edge en production. On cherche un autre dev senior pour livrer plus vite — pas un sauveur.

// Technologies en production

Next.js 16SupabaseTypeScript strictTwilioStripe ConnectResendClaude CodeTailwind v4

Voir le poste

100 % à distance · Québec

system-status.ts

Production · en direct

fonctions Edge Deno en production

intégrations OAuth orchestrées

canaux d'acquisition de prospects

// 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 livrer plus vite. C'est pour ça qu'on cherche un autre dev senior.

Dany D. Therrien

Fondateur, Capturia

01
Un produit qui roule.
Pas un prototype.
Plus de 130 fonctions Edge en production, des intégrations OAuth, des automatisations, des clients qui paient chaque mois. Tu arrives pas dans un projet parti de zéro — tu arrives dans quelque chose qui tourne déjà.
02
Tu codes. Tu révises. Tu livres.
Pas de Jira. Pas de chef de produit.
Pas de planification de sprint à 12 personnes. Tu prends une tâche, tu écris le code, l'équipe le révise, ça fusionne sur develop. La préproduction se déploie. Tu vois ton code dans le produit avant la fin de la journée.
03
Le fondateur est à un message.
Réponse directe en message privé.
Une question ? Écris directement 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 rendez‑vous confirmé, en temps réel.

C'est le flux que tu vas coder : webhooks Twilio, fonctions Edge Deno, RLS multilocataire, synchronisation en temps réel, invalidation TanStack Query. Tout est observable dès que le code est poussé — pas de boîte noire.

step-01.ts

// Étape 01

Prospect Instagram

Il écrit en message privé

fonction Edge · instagram-webhook

signature HMAC · locataire résolu par RLS

step-02.ts

// Étape 02

L'agent IA répond

Conversation qualifiée en quelques secondes

flux Claude · INSERT chat_messages

déclencheur Postgres · synchro unified_threads

step-03.ts

// Étape 03

Rendez‑vous confirmé

Réservé sans intervention humaine

Supabase Realtime · invalidation TanStack

verrou du créneau · réunion Zoom automatique

step-04.ts

// Étape 04

Appel analysé

Température du prospect mise à jour aussitôt

webhook AssemblyAI · classificateur IA

lead.temperature à jour · IntelliSuivi déclenché

Une journée

Du vrai travail de dev, pas de réunions sans fin.

Pas de mêlée quotidienne inutile, pas de planification de sprint à 12 personnes. Tu prends une tâche, tu fais le travail, tu livres.

[09:00:00 INFO] boot.check
15 min
Vérifier que tout tourne
Tu regardes Vercel, les journaux Supabase, les tableaux de bord. Si quelque chose a planté, tu le vois toi-même.
[09:30:00 INFO] code.read
2 h en continu
Lire le code, comprendre les impacts
Tu lis le code existant, tu identifies les impacts de ce que tu vas faire. Après ça seulement, tu commences à coder.
[11:30:00 OK] db.migrate
2 h
Migrations et logique serveur
Migrations MCP, politiques RLS, structure de données. Tu prends ces décisions-là sans demander la permission.
[14:00:00 INFO] review.code
1 h
Révision de code
Tu révises le code de l'équipe et l'équipe révise le tien. Pas juste ce qui cloche — pourquoi ça cloche et comment faire mieux.
[15:30:00 INFO] ship.validate
30 min
Valider et livrer
npm run validate. Zéro avertissement. Tu pousses en production en sachant exactement ce que tu livres.
[16:30:00 OK] sync.founder
10 min
Point avec le fondateur
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 : des devs full-stack, tous solides.

TypeScript strict, révisions de code honnêtes, programmation en binôme quand c'est complexe.
On code pas en silos. On débat des 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 livrent ensemble. C'est tout.

Une équipe qui livre, entre devs solides.

Le filtre

5 indispensables. 5 signaux d'alarme. 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 et plus de développement full-stack en production
Tu as livré et maintenu une base de code en production, pas juste contribué à un projet personnel. React/Next et une solide maîtrise du côté serveur. Tu sais ce que veut dire vivre avec son propre code.
REQ-002
Prendre en charge une base de code existante
Tu sais prendre du code que t'as pas écrit, le lire, comprendre ses conventions, 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 système de types existe et tu t'en sers.
REQ-004
PostgreSQL, pour de vrai
Migrations versionnées, contraintes, RLS, index. Tu sais lire un EXPLAIN ANALYZE et corriger une requête N+1.
REQ-005
Discussion technique d'égal à égal
Ni passif, ni dominateur. Tu défends tes choix avec des arguments, tu changes d'idée quand un argument est meilleur.

Signaux d'alarme

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 de prendre les devants.
FLAG-004
Aucune méthode cohérente — pour 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, fonctions Edge Deno, Realtime. Tu sais quand utiliser quoi.
BONUS-002
OAuth complexe
Zoom, Google, Stripe Connect. Tu as déjà débogué une URL de rappel qui plantait à 2 h du matin.
BONUS-003
SaaS multilocataire en production
De vrais clients qui paient. Pas juste un projet personnel.
BONUS-004
Accompagner et réviser d'autres devs
Tu as déjà encadré des révisions de code. Pas comme un patron — comme un pair.

Candidature

Ça te parle ?

100 % à distance, basé au Québec.

Les champs marqués d'un astérisque (*) sont obligatoires.

Nom complet

Courriel

Téléphone

GitHub ou LinkedIn (optionnel)

Combien d'années d'expérience en développement ?

Montre-nous qui tu es

Ton parcours, un projet qui compte pour toi et ta façon d'aborder de vrais défis.

Curriculum vitæ (optionnel)

Ton CV à jour : ton parcours, tes projets et ce que tu as bâti.

Glisse ton fichier ici ou clique pour le choisirPDF, DOC ou DOCX, 5 Mo au maximum

Portfolio (optionnel)

Un projet dont tu as porté la responsabilité complète, pas seulement une contribution.

La décision difficile et son impact (optionnel)

Comment as-tu entendu parler de nous ? (optionnel)

En soumettant ce formulaire, tu acceptes que nous traitions tes données pour le processus de recrutement.

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

Pourquoi Capturia

Un produit qui roule.

Tu codes. Tu révises. Tu livres.

Le fondateur est à un message.

Du message entrant au rendez‑vous confirmé, en temps réel.

Prospect Instagram

L'agent IA répond

Rendez‑vous confirmé

Appel analysé

Du vrai travail de dev, pas de réunions sans fin.

Vérifier que tout tourne

Lire le code, comprendre les impacts

Migrations et logique serveur

Révision de code

Valider et livrer

Point avec le fondateur

Avec qui tu vas coder.

5 indispensables. 5 signaux d'alarme. Sois honnête avec toi-même.

5 ans et plus de développement full-stack en production

Prendre en charge une base de code existante

TypeScript strict, vraiment strict

PostgreSQL, pour de vrai

Discussion technique d'égal à égal

Supabase en profondeur

OAuth complexe

SaaS multilocataire en production

Accompagner et réviser d'autres devs

Ça te parle ?