14 Lessons from Building Hello Interview

export const scheduleInterview = protectedProcedure
  .input(z.object({
    coachId: z.string(),
    time: z.date(),
    interviewType: z.enum(['BEHAVIORAL', 'SYSTEM_DESIGN', 'CODING'])
  }))
  .mutation(async ({ input, ctx }) => {
    // Implementation
    return interview;
  });

// Frontend - this just works, with autocomplete and everything
const interview = await trpc.scheduleInterview.mutate({
  coachId: "...",
  time: new Date(),
  interviewType: "BEHAVIORAL"
});

export const generateFeedback = protectedProcedure
  .input(z.object({ interviewId: z.string() }))
  .mutation(async function* ({ input, ctx }) {
    // Stream LLM responses in real-time
    for await (const chunk of ctx.deps.streamingCompletion(
      "Provide detailed feedback on this response...",
      { model: "gpt-5" }
    )) {
      yield chunk;
    }
  });

for await (const feedback of trpc.generateFeedback.mutate({ 
  interviewId 
})) {
  setFeedbackText(prev => prev + feedback);
}

# Switch to a new feature branch
git checkout -b new-feature

# Point your local DATABASE_URL to a branch-specific database
yarn db:branch

# Now you have your own isolated database
# Run migrations, test changes, break things - it won't affect anyone else
yarn prisma migrate dev

// This happens automatically for every request
const feedback = await ctx.deps.completion(
  "Generate feedback for this interview...",
  { model: "gpt-4o" }
);
// Cost is logged to the database and OpenTelemetry

// This runs as a workflow - it will complete even if servers crash
export async function processPayment(orderId: string, amount: number) {
  // Step 1: Charge the customer's card
  const charge = await activities.createStripeCharge(orderId, amount);
  
  // Step 2: Update our database with the payment record
  await activities.recordPayment(orderId, charge.id);
  
  // Step 3: Provision the purchased resource (credits, subscription, etc)
  await activities.provisionPurchase(orderId);
  
  // Step 4: Send confirmation email (might be delayed if service is down)
  await activities.sendReceiptEmail(orderId, charge.receiptUrl);
  
  return charge;
}

// In the interview room, multiple users share the same Yjs document
const elements = useMap<string>("drawing/page-1");

// When anyone draws, it syncs automatically to all participants
// No manual WebSocket coordination needed

pub fn find_available_slots(
    coach_availability: &[TimeSlot],
    existing_bookings: &[TimeSlot],
    timezone: &str,
) -> Vec<TimeSlot> {
    // Core logic here
}

# copilot/web/manifest.yml
name: web
type: Load Balanced Web Service
cpu: 2048
memory: 4096

copilot svc deploy --name web --env prod

yarn release

test('can purchase mock', async ({ page }) => {
    await page.goto("https://www.hellointerview.com/landing");
    await page.getByRole("button", { name: "Explore Mock Interviews" }).click();
    // ... walk through the entire flow
    
    // Actually fill in Stripe's iframe
    const paymentFrame = page.locator('[title="Secure payment input frame"]');
    await paymentFrame.locator("#Field-numberInput").fill("4242 4242 4242 4242");
    
    // Pay real money (test mode)
    await page.getByRole("button", { name: "Pay" }).click();
    
    // Then immediately cancel so we don't leave orphan sessions
    await page.locator('[aria-label="Cancel session"]').click();
});

if (type === "gha") {
    // GitHub Actions workflow events
    await temporal.signalWithStart({
        workflowId: `github-monitor-${workflowRunId}`,
        workflowName: "monitorGithubWorkflow",
        signal: "receiveGithubEvent",
        signalArgs: [payload],
    });
} else if (type === "ses") {
    // Email received via SES
    const parsed = await simpleParser(decodedContent);
    // ... process and store email
} else if (type === "livekit") {
    // Video room events
    const event = await livekitReceiver.receive(rawBodyString, authHeader);
    // ... handle participant joined/left
}

export const SupportEmail = SlackBlockTemplate<Props>(({ from, subject, body }) => {
    return <Blocks>
        <Section>
            *From*: {from} {isPremiumUser ? "💎" : ""}<br />
            *Subject*: {subject}
        </Section>
        <Textarea id="response" label="Response" placeholder="Type your response..." />
        <Actions>
            <TypedButton style="primary" actionId="email_respond" value={{ emailReceivedId }}>
                Respond
            </TypedButton>
            <TypedButton style="danger" actionId="email_ignore" value={{ emailReceivedId }}>
                Ignore
            </TypedButton>
        </Actions>
    </Blocks>
});

export const typedActions = {
    "email_respond": {
        schema: z.object({
            emailReceivedId: z.string(),
        }),
    },
    "coach_application_response": {
        schema: z.object({
            coachId: z.string(),
            action: z.enum(["APPROVED", "REJECTED", "WAITLISTED"]),
        })
    },
    // ...
};