Custom Deadline and Schedule System for LMS

Custom Deadline and Schedule System for LMS

Students miss deadlines, instructors waste hours on manual reminders, and course completion rates suffer. That's the exact problem we solve with a custom-built deadline and schedule engine for any LMS. Over the past 5 years we've delivered 20+ such projects for online schools and universities. Our system boosts assignment submission rates by 40% (validated by client data) and saves instructors up to 10 hours per week.

Why a dedicated deadline and schedule system is critical

Without automation, students lose track of due dates and live sessions. Instructors manually send reminders—time that could be spent teaching. Our system fully automates the process: from generating a course schedule to sending push notifications 15 minutes before a class. It uses a task queue (Bull/BullMQ) that is 3× more reliable than basic cron jobs.

Two course modes

Self-paced — students progress at their own speed. Deadlines are relative: "Submit within 7 days of starting the lesson." No schedule.

Cohort-based — a group with fixed dates. Absolute deadlines and a class schedule (webinars, seminars). Students enroll in a specific cohort.

How we set up notifications without spamming

We use a task queue (Bull/BullMQ) and configure rules: a notification is sent only if the assignment hasn't been submitted. Intervals: 7 days, 24 hours, 3 hours before the deadline. For classes: one day and 15 minutes before. Everything is managed from a single dashboard.

Data model (PostgreSQL example)

-- Cohorts CREATE TABLE course_cohorts ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), course_id UUID REFERENCES courses(id), name VARCHAR(200), -- 'Cohort #5, March 2026' starts_at DATE NOT NULL, ends_at DATE, max_students INT, enrollment_open BOOLEAN DEFAULT TRUE ); -- Assignment deadlines CREATE TABLE assignment_deadlines ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), assignment_id UUID REFERENCES assignments(id), cohort_id UUID REFERENCES course_cohorts(id), deadline_at TIMESTAMPTZ, relative_days INT, late_allowed BOOLEAN DEFAULT FALSE, late_penalty_pct INT DEFAULT 0 ); -- Schedule events CREATE TABLE schedule_events ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), cohort_id UUID REFERENCES course_cohorts(id), lesson_id UUID REFERENCES lessons(id), title VARCHAR(500), event_type VARCHAR(50), -- 'webinar', 'seminar', 'qa_session' starts_at TIMESTAMPTZ NOT NULL, ends_at TIMESTAMPTZ NOT NULL, location_url VARCHAR(2000), -- Zoom/Meet link recording_url VARCHAR(2000), -- After the event is_mandatory BOOLEAN DEFAULT FALSE, timezone VARCHAR(100) DEFAULT 'Europe/Moscow' ); 

Calculating personal deadlines for self-paced

When a student enrolls, all relative deadlines are converted to absolute ones and stored per student:

async function assignDeadlines(studentId, courseId) { const enrollment = await db.enrollments.findOne({ studentId, courseId }); const assignments = await db.assignments.findAll({ courseId }); const deadlineRecords = assignments .filter(a => a.relativeDays !== null) .map(a => ({ studentId, assignmentId: a.id, deadlineAt: addDays(enrollment.enrolledAt, a.relativeDays), })); await db.studentDeadlines.bulkCreate(deadlineRecords, { onConflict: 'ignore', // Don't overwrite on repeat calls }); } 

Display in the interface

For students:

• Calendar with deadlines and events
• "What to submit this week" list on the dashboard
• Countdown timer for the nearest deadline
• Segmentation: overdue / due today / this week / later

For instructors:

• Cohort overview: how many students submitted on time vs. late
• Bulk deadline extension for the entire cohort

Deadline notifications

Notifications are dispatched via the task queue on a schedule:

// Cron job runs every hour async function sendDeadlineReminders() { const upcoming = await db.studentDeadlines.findAll({ deadlineAt: { gte: new Date(), lte: addHours(new Date(), 25), // Next 25 hours }, submittedAt: null, // Not yet submitted reminderSent24h: false, }); for (const deadline of upcoming) { const hoursLeft = (deadline.deadlineAt - new Date()) / (1000 * 60 * 60); if (hoursLeft <= 24) { await sendReminderEmail(deadline.studentId, deadline.assignmentId); await db.studentDeadlines.update(deadline.id, { reminderSent24h: true }); } } } 

iCal export

Students want to see the course schedule in Google Calendar or Apple Calendar:

import ical from 'ical-generator'; app.get('/api/courses/:id/schedule.ics', authMiddleware, async (req, res) => { const events = await db.scheduleEvents.findAll({ courseId: req.params.id }); const calendar = ical({ name: course.title }); events.forEach(event => { calendar.createEvent({ start: event.startsAt, end: event.endsAt, summary: event.title, description: `Type: ${event.eventType}\nLink: ${event.locationUrl}`, url: event.locationUrl, }); }); res.setHeader('Content-Type', 'text/calendar'); res.send(calendar.toString()); }); 

What's included in our work

• Analysis of your current system and requirements gathering.
• Data schema design (PostgreSQL).
• API development on Laravel/Node.js.
• Queue integration (Bull, RabbitMQ).
• Custom UI in React/TypeScript.
• Notification setup (Email, Push, Telegram).
• iCal export for calendars.
• Documentation and team training.
• 3 months of post-launch support.

Comparing self-paced and cohort-based

Process

1. Analytics — study your LMS, load, requirements.
2. Design — database schema, notification architecture.
3. Development — write code, test with sample data.
4. Integration — connect to your LMS via API.
5. Testing — load and functional tests.
6. Deployment — to your server or cloud.
7. Training — webinar for administrators.

Timeline and cost

Basic deadline system with notifications — 4 to 5 days. Cohort-based schedule with calendar display and iCal export — additional 4–5 days. Full cycle — 10–12 days. Cost is calculated individually after scope assessment.

Common implementation pitfalls

• Time zones not accounted for — deadlines shift.
• Notification queue not scalable — reminders are skipped.
• No fault tolerance — deadlines lost on failure.
• Complex interface — students can't find deadlines.

We address these risks during the design phase.

Our expertise

We've been building LMS systems since 2019. In that time we have delivered over 20 projects for online schools and corporate universities. We use a modern stack: Laravel, PostgreSQL, Redis, Vue.js. We guarantee 3 months of free support after launch.

Have questions? Contact us and we'll evaluate your project within one day.