How to Integrate Bolt.new with Edmodo (Defunct)

Before writing any code, it is important to understand exactly what happened to Edmodo and evaluate which replacement best fits your needs — because the right choice depends heavily on your audience (K-12 vs. higher education), technical requirements, and existing infrastructure. Edmodo operated as an education social network from 2008 to 2022. It was acquired by NetDragon in 2018 and attempted several pivots before ultimately announcing shutdown in September 2022. The platform cited competitive pressure from Google Classroom, Microsoft Teams for Education, and other well-funded ed-tech products that were provided free to schools as part of larger software bundles. Here is the current landscape of active alternatives and their best use cases: Google Classroom — Best for K-12 schools using Google Workspace. Free for Google Workspace for Education accounts. Has a comprehensive REST API under Google's APIs ecosystem. Most similar to Edmodo's simplified feed-based interface. Widely adopted in the US, UK, and Canada. Canvas LMS — Best for higher education. Open-source core with a hosted option. Extremely comprehensive REST API and LTI integration support. The go-to platform for universities. Available as Canvas Free for Teachers for individual educator accounts. Schoology — Best for K-12 with more advanced needs. Now owned by PowerSchool. Has an API but it requires an Enterprise account for API access. More feature-rich than Google Classroom. Moodle — Best for maximum customization and self-hosting. Open-source LMS with a REST/web services API. Requires a server to host, which makes it more complex but gives you full control. Custom Bolt.new + Supabase — Best when existing platforms don't fit your specific requirements, you need branding control, or you're building a specialized education product (coding bootcamp platform, corporate training, tutoring marketplace). Choose Google Classroom if you are migrating from Edmodo in a K-12 context. Choose Canvas if you are in higher education. Build custom if none of the above fit.

1// app/edmodo-migration/page.tsx
2const alternatives = [
3  {
4    name: 'Google Classroom',
5    bestFor: 'K-12 (Google Workspace schools)',
6    cost: 'Free with Google Workspace for Education',
7    hasApi: true,
8    hasMobileApp: true,
9    keyFeature: 'Deep Google integration (Docs, Drive, Meet)',
10    url: 'https://classroom.google.com',
11  },
12  {
13    name: 'Canvas LMS',
14    bestFor: 'Higher education and universities',
15    cost: 'Free tier for teachers; paid for institutions',
16    hasApi: true,
17    hasMobileApp: true,
18    keyFeature: 'Comprehensive API, LTI integrations, advanced gradebook',
19    url: 'https://www.instructure.com/canvas',
20  },
21  {
22    name: 'Schoology',
23    bestFor: 'K-12 with advanced LMS needs',
24    cost: 'Basic free; Enterprise pricing for API access',
25    hasApi: true,
26    hasMobileApp: true,
27    keyFeature: 'PowerSchool integration, SIS connectivity',
28    url: 'https://www.schoology.com',
29  },
30  {
31    name: 'Moodle',
32    bestFor: 'Organizations needing full control',
33    cost: 'Free (self-hosted); paid for cloud hosting',
34    hasApi: true,
35    hasMobileApp: true,
36    keyFeature: 'Open source, fully customizable, plugin ecosystem',
37    url: 'https://moodle.org',
38  },
39];

Google Classroom is the most commonly chosen Edmodo replacement, especially for K-12 institutions in the US. Its REST API covers the core Edmodo use cases: listing courses, creating announcements, posting assignments, managing rosters, and reading student submissions. The Google Classroom API uses OAuth 2.0 for authentication. For server-side access in Next.js API routes, you use either a service account (for accessing classroom data of users who have delegated access to your app) or a standard OAuth 2.0 user flow (where each teacher authorizes your app to access their classroom data). For a typical school integration tool: implement the user OAuth 2.0 flow so teachers authorize your app from their Google account. When they authorize, you receive access and refresh tokens. Store the refresh token securely in your database. Use it to generate fresh access tokens when calling the Classroom API from your API routes. The googleapis npm package simplifies the authentication setup considerably. Install it, configure the OAuth2 client with your credentials, and use it to call the Classroom API with TypeScript types automatically generated from the API schema. Key endpoints you will use most often: `courses.list()` to get all courses the teacher has, `courses.announcements.list()` for the class feed, `courses.courseWork.list()` for assignments, `courses.courseWork.studentSubmissions.list()` for submitted work, and `courses.students.list()` for the class roster. Important: the Google Classroom API requires scopes to be specified in your OAuth consent screen configuration. The minimum scopes for reading classroom data are `https://www.googleapis.com/auth/classroom.courses.readonly` and `https://www.googleapis.com/auth/classroom.rosters.readonly`.

1// lib/google-classroom.ts
2import { google } from 'googleapis';
3
4export function getOAuth2Client() {
5  return new google.auth.OAuth2(
6    process.env.GOOGLE_CLIENT_ID,
7    process.env.GOOGLE_CLIENT_SECRET,
8    process.env.GOOGLE_REDIRECT_URI
9  );
10}
11
12export function getClassroomClient(refreshToken: string) {
13  const auth = getOAuth2Client();
14  auth.setCredentials({ refresh_token: refreshToken });
15  return google.classroom({ version: 'v1', auth });
16}
17
18// Generate the OAuth authorization URL for teacher onboarding
19export function getAuthUrl(): string {
20  const auth = getOAuth2Client();
21  return auth.generateAuthUrl({
22    access_type: 'offline',
23    scope: [
24      'https://www.googleapis.com/auth/classroom.courses.readonly',
25      'https://www.googleapis.com/auth/classroom.rosters.readonly',
26      'https://www.googleapis.com/auth/classroom.announcements.readonly',
27      'https://www.googleapis.com/auth/classroom.coursework.students.readonly',
28    ],
29  });
30}

If none of the existing platforms meet your requirements — whether you need custom branding, specific features (coding challenge submissions, video assignment responses), or integration with proprietary systems — building a custom classroom platform from scratch in Bolt.new with Supabase is a realistic option. The core data model for a classroom community platform (replicating Edmodo's key features) involves five tables: users (students and teachers), classrooms (virtual class groups), enrollments (linking students to classrooms), posts (announcements, assignments, questions on the class feed), and submissions (student responses to assignment posts). Supabase Row Level Security (RLS) is critical for this use case. Teachers should only see their own classrooms. Students should only see classrooms they are enrolled in. Submissions should only be visible to the submitting student and the classroom teacher. Defining these RLS policies in Supabase ensures data is properly isolated even if there are bugs in your application code. The class feed — Edmodo's signature feature — is a reverse-chronological list of posts in a classroom. Use Supabase's realtime subscriptions to push new posts to connected students without page refresh, recreating the social media-like experience Edmodo was known for. For file submissions (assignment attachments), use Supabase Storage with private buckets — only the submitting student and their teacher can read the file. Generate signed URLs for temporary access when a teacher needs to review a submission. Grade tracking requires a simple join between submissions and a grades table (or a grade column on submissions). A gradebook view aggregates grades per student per assignment in a spreadsheet-style UI.

1-- Supabase migration: create classroom platform tables
2CREATE TABLE classrooms (
3  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
4  name TEXT NOT NULL,
5  description TEXT,
6  join_code TEXT UNIQUE NOT NULL DEFAULT substring(md5(random()::text), 1, 8),
7  teacher_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
8  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
9);
10
11CREATE TABLE enrollments (
12  student_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
13  classroom_id UUID NOT NULL REFERENCES classrooms(id) ON DELETE CASCADE,
14  joined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
15  PRIMARY KEY (student_id, classroom_id)
16);
17
18CREATE TABLE posts (
19  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
20  classroom_id UUID NOT NULL REFERENCES classrooms(id) ON DELETE CASCADE,
21  author_id UUID NOT NULL REFERENCES auth.users(id),
22  title TEXT NOT NULL,
23  content TEXT NOT NULL,
24  type TEXT NOT NULL CHECK (type IN ('announcement', 'assignment', 'question')),
25  due_date TIMESTAMPTZ,
26  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
27);
28
29CREATE TABLE submissions (
30  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
31  post_id UUID NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
32  student_id UUID NOT NULL REFERENCES auth.users(id),
33  content TEXT,
34  file_url TEXT,
35  grade NUMERIC(5, 2),
36  graded_at TIMESTAMPTZ,
37  submitted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
38  UNIQUE (post_id, student_id)
39);
40
41-- Enable RLS
42ALTER TABLE classrooms ENABLE ROW LEVEL SECURITY;
43ALTER TABLE enrollments ENABLE ROW LEVEL SECURITY;
44ALTER TABLE posts ENABLE ROW LEVEL SECURITY;
45ALTER TABLE submissions ENABLE ROW LEVEL SECURITY;
46
47-- RLS Policies
48CREATE POLICY "Teachers see own classrooms" ON classrooms
49  FOR ALL USING (teacher_id = auth.uid());
50
51CREATE POLICY "Students see enrolled classrooms" ON classrooms
52  FOR SELECT USING (
53    EXISTS (SELECT 1 FROM enrollments WHERE classroom_id = id AND student_id = auth.uid())
54  );
55
56CREATE POLICY "Classroom members see posts" ON posts
57  FOR SELECT USING (
58    classroom_id IN (
59      SELECT id FROM classrooms WHERE teacher_id = auth.uid()
60      UNION
61      SELECT classroom_id FROM enrollments WHERE student_id = auth.uid()
62    )
63  );
64
65CREATE POLICY "Students see own submissions" ON submissions
66  FOR SELECT USING (student_id = auth.uid());
67
68CREATE POLICY "Teachers see classroom submissions" ON submissions
69  FOR SELECT USING (
70    post_id IN (
71      SELECT p.id FROM posts p
72      JOIN classrooms c ON c.id = p.classroom_id
73      WHERE c.teacher_id = auth.uid()
74    )
75  );

Whether you chose the Google Classroom integration route, the Canvas LMS integration, or the custom Supabase-based classroom build, deploying to Netlify is the same process. The deployment converts your Bolt.new app from the WebContainer preview into a production-ready application. For the Google Classroom integration path: after deployment, you need a real public URL for the OAuth redirect — Google's OAuth consent screen requires a registered redirect URI. Add your Netlify URL (e.g., `https://your-app.netlify.app/api/auth/callback`) to your Google Cloud OAuth credentials and update `GOOGLE_REDIRECT_URI` in Netlify's environment variables. This is the only step that requires a deployed URL — all the actual Classroom API calls work in WebContainer development without a public redirect URI. For the Canvas LMS integration: Canvas API tokens do not have OAuth flows that require redirect URIs, so this integration works entirely in the WebContainer and deploys without any URL-dependent setup. For the custom Supabase platform: Supabase works identically in development and production since it is an external service. After deploying to Netlify, add `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_ANON_KEY` to Netlify's environment variables. The RLS policies run server-side on Supabase regardless of where your app is deployed. A production classroom platform should also consider: email notifications when new posts are added (integrate with SendGrid or Resend), push notifications for assignment due dates (using a service worker), and file size limits on submission uploads. These are enhancement items for after your initial deployment.

1// netlify.toml
2[[plugins]]
3package = "@netlify/plugin-nextjs"
4
5[build]
6  command = "npm run build"
7  publish = ".next"
8
9[build.environment]
10  NEXT_TELEMETRY_DISABLED = "1"
11
12# Environment variables needed in Netlify dashboard:
13# For custom Supabase classroom:
14#   NEXT_PUBLIC_SUPABASE_URL
15#   NEXT_PUBLIC_SUPABASE_ANON_KEY
16# For Google Classroom integration:
17#   GOOGLE_CLIENT_ID
18#   GOOGLE_CLIENT_SECRET
19#   GOOGLE_REDIRECT_URI  (https://your-app.netlify.app/api/auth/callback)
20# For Canvas LMS integration:
21#   CANVAS_BASE_URL  (e.g., https://canvas.instructure.com)
22#   CANVAS_API_TOKEN