Building an AI-Powered Lead Management System with Next.js

1// Atomic transaction: Lead + Analysis created together
2const lead = await prisma.lead.create({
3  data: {
4    fullName: parsed.data.fullName,
5    email: parsed.data.email,
6    // ... other fields
7    analysis: {
8      create: {
9        score: analysis.score,
10        priority: analysis.priority,
11        summary: analysis.summary,
12        recommendation: analysis.recommendation,
13      },
14    },
15  },
16});

1export async function analyzeLead(leadData: LeadAnalysisInput) {
2  if (!genAI) return null; // Graceful degradation
3  
4  const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
5  const result = await model.generateContent(prompt);
6  
7  // Parse JSON from AI response
8  const analysis = JSON.parse(jsonMatch[0]);
9  
10  // Validate and clamp scores
11  analysis.score = Math.max(0, Math.min(100, analysis.score));
12  
13  return analysis;
14}

1// API route protection
2export async function requireApiAuth(): Promise<AuthUser> {
3  const { data: session } = await auth.getSession();
4  
5  if (!session?.user) {
6    throw new AuthError("Unauthorized", 401);
7  }
8  
9  return {
10    id: session.user.id,
11    email: session.user.email,
12    name: session.user.name,
13    role: session.user.role,
14  };
15}

1model Lead {
2  id          String   @id @default(cuid())
3  fullName    String
4  email       String
5  phone       String?
6  company     String?
7  budget      String?
8  projectType String?
9  message     String
10  status      LeadStatus @default(NEW)
11  
12  // Relations
13  analysis      LeadAnalysis?
14  workflowLogs  WorkflowLog[]
15  followUps     FollowUp[]
16  followUpLogs  FollowUpLog[]
17  
18  createdAt   DateTime @default(now())
19  updatedAt   DateTime @updatedAt
20}

1model LeadAnalysis {
2  id              String   @id @default(cuid())
3  leadId          String   @unique
4  lead            Lead     @relation(fields: [leadId], references: [id], onDelete: Cascade)
5  
6  score           Int      @default(0)
7  priority        Priority @default(LOW)
8  budgetCategory  String?
9  summary         String   @db.Text
10  recommendation  String   @db.Text
11  
12  createdAt       DateTime @default(now())
13  updatedAt       DateTime @updatedAt
14}

1model FollowUp {
2  id              String          @id @default(cuid())
3  leadId          String
4  followUpNumber  Int             // 1st, 2nd, 3rd
5  subject         String
6  content         String?         @db.Text
7  status          FollowUpStatus  @default(PENDING)
8  channel         FollowUpChannel @default(EMAIL)
9  scheduledFor    DateTime
10  sentAt          DateTime?
11  errorMessage    String?         @db.Text
12  
13  @@index([leadId, status])
14  @@index([status, scheduledFor])
15}

1model AIInsight {
2  id              String        @id @default(cuid())
3  summary         String        @db.Text
4  recommendations String        @db.Text
5  keyFindings     String        @db.Text
6  riskAlerts      String?       @db.Text
7  opportunities   String?       @db.Text
8  period          InsightPeriod // WEEKLY or MONTHLY
9  createdAt       DateTime      @default(now())
10  
11  @@index([period, createdAt])
12}

1const prompt = `You are a lead qualification expert for a software development agency.
2
3Lead Information:
4- Name: ${leadData.fullName}
5- Email: ${leadData.email}
6- Company: ${leadData.company || "Not provided"}
7- Budget: ${leadData.budget || "Not provided"}
8- Message: ${leadData.message}
9
10Provide analysis in JSON format:
11{
12  "score": <number from 0-100>,
13  "priority": "LOW" | "MEDIUM" | "HIGH",
14  "budgetCategory": <string>,
15  "summary": <2-3 sentence summary>,
16  "recommendation": <specific next action>
17}
18
19Scoring guidelines:
20- Score 80-100: High budget, clear scope, urgent timeline
21- Score 50-79: Moderate budget, reasonable scope
22- Score 0-49: Low budget, vague requirements`;

1const jsonMatch = text.match(/\{[\s\S]*\}/);
2if (!jsonMatch) throw new Error("No JSON found");
3
4const analysis = JSON.parse(jsonMatch[0]);
5
6if (
7  typeof analysis.score !== "number" ||
8  !["LOW", "MEDIUM", "HIGH"].includes(analysis.priority)
9) {
10  throw new Error("Invalid response structure");
11}
12
13analysis.score = Math.max(0, Math.min(100, analysis.score));

1// Duplicate prevention
2const existing = await prisma.followUp.findFirst({
3  where: { leadId: lead.id, followUpNumber: followUpNumber },
4});
5
6if (existing) {
7  console.log(`Follow-up ${followUpNumber} already exists for lead ${lead.id}`);
8  continue;
9}

1// Error handling
2try {
3  await sendEmail({ to: lead.email, subject: followUp.subject, html: followUp.content });
4  await prisma.followUp.update({
5    where: { id: followUp.id },
6    data: { status: "SENT", sentAt: new Date() },
7  });
8} catch (error) {
9  await prisma.followUp.update({
10    where: { id: followUp.id },
11    data: { status: "FAILED", errorMessage: error.message },
12  });
13}

1export async function retryOperation<T>(
2  operation: () => Promise<T>,
3  options: { maxRetries: number; delayMs: number; operationName: string }
4): Promise<T> {
5  let lastError: Error;
6  
7  for (let attempt = 1; attempt <= options.maxRetries; attempt++) {
8    try {
9      return await operation();
10    } catch (error) {
11      lastError = error;
12      if (error.code === "P2002") throw error; // Don't retry validation errors
13      if (attempt < options.maxRetries) {
14        await sleep(options.delayMs);
15      }
16    }
17  }
18  
19  throw lastError;
20}

1export async function requireApiAuth(): Promise<AuthUser> {
2  const { data: session } = await auth.getSession();
3  if (!session?.user) throw new AuthError("Unauthorized", 401);
4  return { id: session.user.id, email: session.user.email, name: session.user.name, role: session.user.role };
5}