# How to Integrate Bolt.new with Udacity - Tool: Bolt.new - Difficulty: Intermediate - Time required: 30 minutes - Last updated: April 2026 ## TL;DR Udacity has no public API for third-party developers. To use Udacity content in a Bolt.new app, your options are: (1) link to Udacity nanodegrees via their affiliate program, (2) build a comparable project-based learning platform in Bolt with Supabase covering courses, project submissions, mentor matching, and progress tracking, or (3) use freeCodeCamp's open GitHub-based curriculum for programmatic access to tech education content. ## Building a Tech Education Platform with Bolt.new Without a Udacity API Udacity built its reputation on nanodegrees — intensive, project-based programs designed to get learners job-ready in technology fields. Unlike traditional online courses that end with a quiz, Udacity nanodegrees require learners to build and submit real projects reviewed by human mentors. This hands-on, career-focused model has made Udacity popular for tech professionals seeking structured skill development in AI, machine learning, data engineering, and cloud architecture. However, Udacity does not offer a public API for third-party developers. There is no developer portal, no API key management interface, and no documented REST endpoints for accessing course catalogs, enrollment data, or learner progress. Udacity is built as a destination platform — learners go to Udacity's website to learn, not through external apps. This is a deliberate product decision, and it means building a direct Udacity data integration is not possible with their current platform. For Bolt.new developers looking to incorporate Udacity-style functionality or content into their apps, there are practical alternatives. The most direct option is Udacity's partner/referral program for linking to their nanodegrees. For developers who want to build a full project-based learning experience — the core of what makes Udacity distinctive — building it from scratch in Bolt.new with Supabase is surprisingly achievable in a few hours: course catalog, project submission workflow, mentor review queue, and learner dashboards. For free tech education content, freeCodeCamp maintains its entire curriculum on GitHub as structured JSON, making it the most developer-friendly source of tech course content. This guide covers all three paths. ## Before you start - A Bolt.new account with a Next.js or React project using TypeScript and Tailwind CSS - A Supabase account (free tier is sufficient) if building a custom learning platform with user accounts and progress tracking - A Udacity account and approval through their partner/affiliate program for generating affiliate tracking links to nanodegrees - A GitHub personal access token if making many GitHub API calls to freeCodeCamp's repo — unauthenticated requests are rate-limited to 60 per hour - No deployment required for the affiliate link or curriculum browser approaches — both work in Bolt's WebContainer preview immediately ## Step-by-step guide ### 1. Understand Udacity's limitations and choose the right approach Udacity's decision not to provide a public developer API places it in a similar position to FutureLearn and LinkedIn Learning — platforms built for learners, not for developers to build on top of. Understanding why helps you choose the right strategy without wasting time on approaches that will not work. Udacity was founded in 2011 by Sebastian Thrun after his Stanford AI course enrolled 160,000 students. The nanodegree model launched in 2014 with a focus on project-based learning with human mentor feedback — a significantly more labor-intensive model than self-paced video courses. The company went private in 2023 and has gone through multiple rounds of restructuring. Today, Udacity operates as a B2C and enterprise learning platform, with many programs delivered as 'Udacity for Business' to corporate clients. None of these product lines expose a developer API. For Bolt.new developers, the three viable paths are worth weighing carefully before choosing. The affiliate path is fastest but creates dependency on Udacity's platform — if Udacity changes a program, your links break, and you are not building a reusable product. The custom platform path takes longer but delivers genuine product value: you own the curriculum, the learner data, and the learning experience. The freeCodeCamp API path sits in between: it gives you access to a large, high-quality tech curriculum for free, and freeCodeCamp actively encourages developers to use their open-source content. For most developers asking 'how do I integrate Udacity with Bolt.new,' the real question is: 'How do I build a tech learning experience in Bolt.new?' The answer is building your own, informed by what makes Udacity successful: structured programs, project-based assessment, and progress tracking. Supabase provides the backend infrastructure to support all of this. Alternatively, if you specifically need nanodegree-style content from an established provider, Coursera has a documented catalog API that is accessible without any partner approval. ``` -- supabase/migrations/001_learning_platform.sql CREATE TABLE programs ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title TEXT NOT NULL, slug TEXT UNIQUE NOT NULL, description TEXT, duration_weeks INTEGER, level TEXT CHECK (level IN ('Beginner', 'Intermediate', 'Advanced')), partner_companies TEXT[] DEFAULT '{}', thumbnail_url TEXT, published BOOLEAN DEFAULT false, created_at TIMESTAMPTZ DEFAULT now() ); CREATE TABLE modules ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), program_id UUID REFERENCES programs(id) ON DELETE CASCADE NOT NULL, title TEXT NOT NULL, description TEXT, order_index INTEGER NOT NULL ); CREATE TABLE projects ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), module_id UUID REFERENCES modules(id) ON DELETE CASCADE NOT NULL, title TEXT NOT NULL, description TEXT, rubric JSONB DEFAULT '[]', min_passing_score INTEGER DEFAULT 70, order_index INTEGER NOT NULL ); CREATE TABLE enrollments ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), learner_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL, program_id UUID REFERENCES programs(id) ON DELETE CASCADE NOT NULL, started_at TIMESTAMPTZ DEFAULT now(), UNIQUE(learner_id, program_id) ); CREATE TABLE submissions ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), project_id UUID REFERENCES projects(id) ON DELETE CASCADE NOT NULL, learner_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL, github_url TEXT NOT NULL, notes TEXT, status TEXT DEFAULT 'pending' CHECK (status IN ('pending', 'in_review', 'passed', 'failed')), submitted_at TIMESTAMPTZ DEFAULT now() ); -- RLS ALTER TABLE programs ENABLE ROW LEVEL SECURITY; ALTER TABLE modules ENABLE ROW LEVEL SECURITY; ALTER TABLE projects ENABLE ROW LEVEL SECURITY; ALTER TABLE enrollments ENABLE ROW LEVEL SECURITY; ALTER TABLE submissions ENABLE ROW LEVEL SECURITY; CREATE POLICY "Read published programs" ON programs FOR SELECT USING (published = true); CREATE POLICY "Read modules" ON modules FOR SELECT USING (true); CREATE POLICY "Read projects" ON projects FOR SELECT USING (true); CREATE POLICY "Own enrollments" ON enrollments USING (learner_id = auth.uid()) WITH CHECK (learner_id = auth.uid()); CREATE POLICY "Own submissions" ON submissions USING (learner_id = auth.uid()) WITH CHECK (learner_id = auth.uid()); ``` **Expected result:** The Supabase database has five tables covering programs, modules, projects, enrollments, and project submissions with proper RLS policies. The schema mirrors Udacity's core learning model and is ready for the application layer. ### 2. Build the learner dashboard with program progress The learner dashboard is the central interface of the platform — it shows the enrolled learner's progress through each program, which modules are complete, which projects are pending submission or under review, and which projects they have passed. This is the equivalent of Udacity's 'My Learning' page. Progress calculation works by counting passed submissions for a program's projects relative to total projects. Query the enrollments table to get programs the learner is in, then count projects per program and passed submissions per program. Construct a progress percentage: (passed submissions count / total projects in program) * 100. Each program card on the dashboard shows: program title, thumbnail, partner company logos (from the partner_companies array), overall progress bar, current module, and a 'Continue' button linking to the next incomplete project. The 'next incomplete project' query joins enrollments → programs → modules → projects and filters for projects without a 'passed' submission by the current user, ordered by module order_index then project order_index, taking the first result. Project status indicators use color coding: gray for not started, yellow for pending review, green for passed, red for failed (with a 're-submit' prompt). These status indicators make it immediately clear where the learner is in their journey and what action is needed next. For the mentor review queue (visible to users with a 'mentor' role), query submissions with status = 'pending' ordered by submitted_at ascending (oldest first). Display the learner name, project title, GitHub URL, submission notes, and a 'Start Review' button that changes status to 'in_review' and locks the submission to that mentor. ``` // app/dashboard/page.tsx import { createClient } from '@/lib/supabase/server'; import { redirect } from 'next/navigation'; import Link from 'next/link'; export default async function DashboardPage() { const supabase = await createClient(); const { data: { user } } = await supabase.auth.getUser(); if (!user) redirect('/login'); // Fetch enrollments with program data const { data: enrollments } = await supabase .from('enrollments') .select(` id, started_at, programs ( id, title, slug, thumbnail_url, partner_companies, modules ( id, order_index, projects ( id ) ) ) `) .eq('learner_id', user.id); // Fetch user's passed submissions const { data: passedSubs } = await supabase .from('submissions') .select('project_id') .eq('learner_id', user.id) .eq('status', 'passed'); const passedProjectIds = new Set(passedSubs?.map((s) => s.project_id) ?? []); const programProgress = enrollments?.map((e) => { const program = e.programs as { id: string; title: string; slug: string; thumbnail_url?: string; partner_companies: string[]; modules: { id: string; order_index: number; projects: { id: string }[] }[] }; const allProjects = program.modules.flatMap((m) => m.projects); const passed = allProjects.filter((p) => passedProjectIds.has(p.id)).length; const percentage = allProjects.length > 0 ? Math.round((passed / allProjects.length) * 100) : 0; return { ...program, passed, total: allProjects.length, percentage }; }) ?? []; return (

My Learning

{programProgress.length === 0 ? (

You are not enrolled in any programs yet.

Browse Programs
) : (
{programProgress.map((p) => (

{p.title}

{p.passed}/{p.total} projects completed

{p.percentage}%

Continue
))}
)}
); } ``` **Expected result:** The learner dashboard shows enrolled programs as cards with real progress bars calculated from passed project submissions. An unenrolled user sees a 'Browse Programs' call to action. Progress percentages update as project submissions are marked as passed. ### 3. Build the project submission and mentor review workflow The project submission workflow is what makes Udacity's model distinctive: learners do not just watch videos and take quizzes — they build projects and submit them for human review. This step implements that core loop in Bolt.new. The submission form is displayed on each project's detail page. It accepts a GitHub repository URL (where the learner has pushed their project code) and optional notes to the reviewer. Client-side validation ensures the URL is a valid GitHub URL before submitting. The form calls a Server Action that inserts a new row into the submissions table with status = 'pending'. The mentor review interface is a separate page accessible only to users with a mentor role. Implement role-based access by adding a roles column to the auth.users profile table (via Supabase's public profiles table). Mentors see a queue of pending submissions sorted by submission time. Clicking a submission opens a review panel showing the project rubric, the learner's GitHub URL, and a scoring interface. The rubric is stored as a JSONB array in the projects table. Each rubric item has a criterion (string) and a weight (number 0-100). The mentor scores each criterion from 0-100 and adds written feedback. The overall score is the weighted average. If the score meets the project's min_passing_score, the reviewer clicks 'Pass' which sets status = 'passed'. Otherwise, 'Request Revision' sets status = 'failed' and the learner gets a notification to resubmit. For real-time notifications when a submission is reviewed, Supabase Realtime listens to changes in the submissions table for the current user's rows. When a submission's status changes from 'in_review' to 'passed' or 'failed', a toast notification appears in the learner's dashboard. This uses Supabase's channel subscription pattern with the JavaScript client. ``` // app/actions/submissions.ts 'use server'; import { createClient } from '@/lib/supabase/server'; import { redirect } from 'next/navigation'; export async function submitProject(formData: FormData) { const supabase = await createClient(); const { data: { user } } = await supabase.auth.getUser(); if (!user) redirect('/login'); const projectId = formData.get('projectId') as string; const githubUrl = formData.get('githubUrl') as string; const notes = formData.get('notes') as string; // Validate GitHub URL const isGitHubUrl = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+/.test(githubUrl); if (!isGitHubUrl) { return { error: 'Please enter a valid GitHub repository URL (https://github.com/username/repo)' }; } // Check for existing pending or in_review submission const { data: existing } = await supabase .from('submissions') .select('id, status') .eq('project_id', projectId) .eq('learner_id', user.id) .in('status', ['pending', 'in_review']) .maybeSingle(); if (existing) { return { error: `You already have a submission ${existing.status === 'pending' ? 'waiting for review' : 'currently under review'}` }; } const { error } = await supabase.from('submissions').insert({ project_id: projectId, learner_id: user.id, github_url: githubUrl, notes: notes || null, status: 'pending', }); if (error) { return { error: `Submission failed: ${error.message}` }; } return { success: true }; } ``` **Expected result:** Learners can submit GitHub URLs for projects, which appear in the mentor queue with 'pending' status. Mentors can click 'Start Review' to claim a submission, which changes its status to 'in_review'. The learner's dashboard shows the updated status with color-coded badges. ### 4. Add freeCodeCamp curriculum content via GitHub API as a free tech content source For developers who want to offer tech education content without writing all curriculum from scratch, freeCodeCamp is the best free option. freeCodeCamp maintains its entire curriculum as open-source JSON files on GitHub at github.com/freeCodeCamp/freeCodeCamp. The curriculum is organized into certification tracks (Responsive Web Design, JavaScript Algorithms, Data Structures, etc.), each containing modules (SuperBlocks) and individual challenges. All of this is accessible via the GitHub API. The GitHub Contents API lets you browse the directory structure of any public repository. freeCodeCamp's curriculum lives at curriculum/challenges/english in their repository. Each subdirectory is a certification track. The JSON files inside describe individual challenges with titles, descriptions, instructions, seed code, and test cases. Be aware of GitHub API rate limits. Unauthenticated requests are limited to 60 per hour per IP — enough for development but not for a production app with multiple users. Add a GitHub personal access token (no special scopes needed for public repos) in GITHUB_TOKEN in your .env file and include it as an Authorization: Bearer {token} header in API calls. Authenticated requests get 5,000 per hour. For a good user experience, cache the curriculum structure in your Supabase database rather than fetching from GitHub on every page load. A nightly cron job (or a manual admin trigger) refreshes the cached curriculum from GitHub. The curriculum structure (certification titles, module titles, challenge counts) changes infrequently, so caching it for 24 hours is safe. The individual challenge content is what changes — fetch it on-demand when a learner opens a specific challenge. Note that freeCodeCamp's license is BSD 3-Clause for the codebase and CC BY-SA 4.0 for the curriculum content. You are free to use the curriculum content in your app with attribution. Display a 'Curriculum from freeCodeCamp.org' credit wherever you show freeCodeCamp content. ``` // app/api/fcc/certifications/route.ts import { NextResponse } from 'next/server'; interface GitHubContentItem { name: string; path: string; type: 'file' | 'dir'; url: string; } export async function GET() { const token = process.env.GITHUB_TOKEN; const headers: HeadersInit = { Accept: 'application/vnd.github.v3+json', 'User-Agent': 'Bolt-Learning-App/1.0', }; if (token) headers['Authorization'] = `Bearer ${token}`; try { const response = await fetch( 'https://api.github.com/repos/freeCodeCamp/freeCodeCamp/contents/curriculum/challenges/english', { headers, next: { revalidate: 3600 } } // Cache for 1 hour ); if (!response.ok) { if (response.status === 403) { return NextResponse.json( { error: 'GitHub API rate limit exceeded. Add GITHUB_TOKEN to .env to increase limit.' }, { status: 429 } ); } return NextResponse.json({ error: `GitHub API error: ${response.status}` }, { status: 500 }); } const items: GitHubContentItem[] = await response.json(); const certifications = items .filter((item) => item.type === 'dir') .map((item) => ({ name: item.name .replace(/-/g, ' ') .replace(/\b\w/g, (c) => c.toUpperCase()), slug: item.name, path: item.path, })); return NextResponse.json({ certifications }); } catch (error) { const message = error instanceof Error ? error.message : 'Request failed'; return NextResponse.json({ error: message }, { status: 500 }); } } ``` **Expected result:** The learn page displays freeCodeCamp certification tracks as clickable cards. Clicking a certification shows its modules. The content loads from GitHub's API with proper caching. A rate limit error message appears if GITHUB_TOKEN is not set and the 60 req/hr limit is reached. ## Best practices - Be transparent about platform limitations — if you are building a 'Udacity-like' platform, you own the curriculum and are responsible for content quality; set clear expectations with learners about what your platform is - For the affiliate approach, keep your course database in Supabase and update it quarterly — Udacity regularly retires, updates, and reprices programs, and stale affiliate links hurt user trust and SEO - Enable Row Level Security on all learning platform tables from the start — a learner should never be able to see another learner's submissions or progress data - Store GitHub repo URLs in project submissions rather than code snippets — this gives reviewers access to full commit history and reduces submission form complexity - Add a status change notification system using Supabase Realtime or database triggers — learners should know immediately when their submission has been reviewed without manually refreshing the page - Cache freeCodeCamp curriculum structure in Supabase for 24 hours rather than fetching from GitHub on every request — the curriculum tree changes infrequently and GitHub API rate limits are real constraints in production - Protect mentor-only routes with both middleware-level auth checks and RLS policies — never rely on UI-only access control to hide sensitive review interfaces ## Use cases ### Tech Career Resource Hub with Udacity Affiliate Links A curated website for aspiring tech professionals that lists Udacity nanodegrees alongside other learning resources, with affiliate tracking links. The site is filtered by job role (data scientist, ML engineer, cloud architect) and links out to the relevant Udacity nanodegrees. Built entirely in Bolt.new with a static or Supabase-backed course database — no API needed. Prompt example: ``` Build a tech learning resource hub for career changers. Create a Supabase table 'tech_programs' with columns: id, title, provider (default 'Udacity'), role_focus, duration_months, level, description, skills array text[], partner_companies text[], affiliate_url, image_url, featured boolean. Seed it with 5 Udacity nanodegrees (AI Product Manager, Machine Learning Engineer, Data Scientist, Cloud DevOps, React). Display them as cards filterable by role_focus. Each card shows title, duration, partner companies, and a 'View Nanodegree' button opening the affiliate_url. Use Tailwind CSS and shadcn/ui. ``` ### Project-Based Learning Platform Inspired by Udacity A custom learning platform with Udacity's signature features: structured project submissions, mentor code review, and a learner dashboard showing progress through a nanodegree-style curriculum. Built entirely in Bolt.new with Supabase — course content, project rubrics, submission uploads, and review feedback all in your own database. Prompt example: ``` Build a project-based learning platform. Create Supabase tables: programs (id, title, description, duration_weeks), modules (id, program_id, title, order_index), projects (id, module_id, title, description, rubric jsonb, passing_score), submissions (id, project_id, learner_id, github_url, notes, status: pending/in_review/passed/failed, submitted_at), reviews (id, submission_id, reviewer_id, score, feedback, reviewed_at). Build: (1) a learner dashboard showing their program progress and pending submissions, (2) a project submission form that accepts a GitHub URL and notes, (3) a mentor review queue showing pending submissions. Use Supabase Auth for learner and mentor accounts with different role access. ``` ### freeCodeCamp Curriculum Browser Using GitHub API A searchable browser of freeCodeCamp's open-source tech curriculum fetched directly from their GitHub repository. freeCodeCamp stores all course content as structured JSON on GitHub, making it programmatically accessible via the GitHub API. Displays certifications, challenges, and projects in a custom interface built in Bolt.new. Prompt example: ``` Build a freeCodeCamp curriculum browser. Create a Next.js API route at /api/freecodecamp/curriculum that fetches the list of certifications from freeCodeCamp's GitHub repo (https://api.github.com/repos/freeCodeCamp/freeCodeCamp/contents/curriculum/challenges/english) and returns folder names (each folder is a certification). Add a second endpoint /api/freecodecamp/certification/[name] that fetches the subfolder contents to get course modules. Display certifications as cards with a title and lesson count. Add a search input. Include a 'Start on freeCodeCamp' link to https://www.freecodecamp.org/learn. Handle GitHub API rate limits gracefully. ``` ## Troubleshooting ### GitHub API returns 403 Forbidden with a 'rate limit exceeded' message when fetching freeCodeCamp curriculum Cause: Unauthenticated GitHub API requests are limited to 60 per hour per IP address. In development, each browser refresh or hot reload may trigger new API calls, quickly exhausting the limit. Multiple developers on the same network share the same rate limit pool. Solution: Generate a GitHub personal access token at github.com/settings/tokens (no special scopes needed for public repository access). Add GITHUB_TOKEN to your .env file and include it as an Authorization: Bearer {token} header in your API route's fetch calls. Authenticated requests get 5,000 requests per hour. Also add next: { revalidate: 3600 } to cache responses for one hour in Next.js. ``` // Add auth header and caching to GitHub API calls const token = process.env.GITHUB_TOKEN; const headers: HeadersInit = { 'User-Agent': 'MyApp/1.0' }; if (token) headers['Authorization'] = `Bearer ${token}`; const response = await fetch(url, { headers, next: { revalidate: 3600 }, // Cache for 1 hour }); ``` ### Supabase returns 'new row violates row-level security policy' when a learner tries to enroll in a program or submit a project Cause: The RLS policy for the enrollments or submissions table requires learner_id = auth.uid(), but the request is being made without a valid Supabase auth session, or the auth session is not being passed to the server client correctly. Solution: Use the Supabase server client (createClient from '@/lib/supabase/server') in Server Actions — it automatically reads the auth cookie from the request headers. If using the browser client in a Client Component, ensure the user is signed in before calling insert. Check that your Supabase client configuration includes proper cookie handling for Next.js App Router. ``` // In Server Actions — use server client which reads auth cookies automatically import { createClient } from '@/lib/supabase/server'; export async function enrollInProgram(programId: string) { const supabase = await createClient(); // This reads the auth session from cookies const { data: { user } } = await supabase.auth.getUser(); if (!user) redirect('/login'); // Now supabase insert will have auth.uid() populated await supabase.from('enrollments').insert({ learner_id: user.id, program_id: programId }); } ``` ### The project submission form allows re-submission of projects that are already pending or under review, creating duplicate submission rows Cause: The submission form does not check for existing active submissions before inserting a new one. The submissions table does not have a unique constraint on (project_id, learner_id, status). Solution: Add a pre-insert check in the Server Action that queries for existing submissions with status 'pending' or 'in_review' for the same project and learner. Return an error if one exists. Optionally, add a partial unique index in Supabase: CREATE UNIQUE INDEX ON submissions (project_id, learner_id) WHERE status IN ('pending', 'in_review'). This enforces the constraint at the database level. ``` -- Add a partial unique index to prevent duplicate active submissions CREATE UNIQUE INDEX unique_active_submission ON submissions (project_id, learner_id) WHERE status IN ('pending', 'in_review'); -- Now insert attempts for duplicate active submissions will return a unique constraint error -- Handle error code '23505' in your Server Action as 'already submitted' ``` ## Frequently asked questions ### Does Udacity have a public API that works with Bolt.new? No. Udacity does not provide a public developer API. There is no API key management interface, no developer documentation for external REST endpoints, and no OAuth application registration available to independent developers. If you need programmatic access to online tech education content, Coursera's catalog API is the closest free alternative that works with Bolt.new's API route pattern. ### Can I build a project review system like Udacity's in Bolt.new? Yes — Bolt.new with Supabase can support the core Udacity model: project submission forms, a mentor review queue, rubric-based scoring, and pass/fail status updates. The schema in this guide covers all of these tables. Supabase's row-level security handles access control between learners and mentors. The full workflow — submit GitHub URL, mentor reviews and scores, learner gets result — can be built in Bolt in a few hours. ### How can I use freeCodeCamp content in my Bolt.new learning app? freeCodeCamp maintains its curriculum as open-source JSON on GitHub at github.com/freeCodeCamp/freeCodeCamp. You can access it via the GitHub Contents API from a Next.js API route — fetch the directory listing at curriculum/challenges/english to get certification tracks, and individual JSON files for challenge content. freeCodeCamp's curriculum is licensed CC BY-SA 4.0, so you can use it with attribution. Add a GitHub personal access token to avoid rate limits. ### Does the Udacity-like learning platform work in Bolt's WebContainer preview? Yes — the course catalog, enrollment, project submission forms, and mentor queue all use Supabase over HTTP, which works perfectly in Bolt's WebContainer. Supabase's JavaScript client communicates via REST API, not raw TCP, so there are no WebContainer compatibility issues. The only features that require deployment are Supabase Auth's OAuth social login flows (Google, GitHub) which need stable redirect URLs that the WebContainer cannot provide. ### How do I deploy a Bolt.new learning platform to Netlify? Use Bolt's Netlify integration under Settings → Applications or push to GitHub and connect to Netlify. In Netlify's environment variables, add NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY from your Supabase project settings. If using the GitHub API for freeCodeCamp content, also add GITHUB_TOKEN. After deploying, update any Supabase Auth redirect URLs to include your Netlify domain for social login providers. --- Source: https://www.rapidevelopers.com/bolt-ai-integrations/udacity © RapidDev — https://www.rapidevelopers.com/bolt-ai-integrations/udacity