Inspiration
As students, we often receive important assignment, exam, project, and presentation dates inside long syllabus documents. Copying every deadline into a calendar manually is repetitive, and it is easy to miss a date or overlook a week containing several major deadlines.
We wanted to build something that could reduce this work without asking students to blindly trust automation.
That inspired CourseFlow: a student planning application that turns syllabus text or a PDF into a reviewed, conflict-aware study calendar.
Our main design principle was:
Automation proposes. The student verifies.
What it does
CourseFlow follows a four-stage workflow:
IMPORT → REVIEW → RESOLVE → EXPORT
1. Import
Students can:
- Paste syllabus text
- Upload a text-based syllabus PDF
- Select the academic year
- Set the semester start and end dates
CourseFlow extracts possible assignments, exams, projects, and presentations from the submitted content.
2. Review
Every extracted deadline includes:
- Event title
- Due date
- Event type
- Estimated effort
- Suggested preparation date
- Original source sentence
Students can edit, approve, or reject every result. If CourseFlow misses a deadline, the student can add it manually.
3. Resolve
CourseFlow checks approved deadlines for:
- Multiple deadlines on the same day
- Heavy seven-day workloads
- Dates that need review
- Deadlines outside the selected semester
Warnings update whenever a student edits, adds, approves, or rejects an event.
4. Export
After reviewing the results, students can download the approved deadlines as a standard .ics calendar file.
The file can be imported into applications that support the iCalendar format, including Google Calendar, Microsoft Outlook, and Apple Calendar.
How we built it
CourseFlow uses a React and TypeScript frontend with a Python and FastAPI backend.
Frontend
The frontend was built with:
- React
- TypeScript
- Vite
- CSS
- Lucide icons
It provides the syllabus import form, semester settings, deadline review interface, workload warnings, benchmark explanation, and calendar download experience.
Backend
The backend was built with:
- Python
- FastAPI
- Pydantic
- PyMuPDF
- python-dateutil
- Pytest
PyMuPDF extracts text from uploaded PDFs. CourseFlow then uses deterministic date patterns and date parsing to find common formats, including:
September 25, 2026Sep 25th, 202609/25/20262026-09-25- Dates without a year, using the selected academic year
Surrounding words are used to classify events as assignments, exams, projects, presentations, or other deadlines.
The backend also applies deterministic conflict rules and generates the final .ics calendar file.
Architecture
Student
↓
React + TypeScript interface
↓
FastAPI API
├── PDF text extraction
├── Date parsing
├── Event classification
├── Conflict detection
└── ICS generation
↓
Reviewed calendar download
The frontend and API are deployed as separate Vercel projects. Environment variables connect the frontend to the API, and production CORS is restricted to the deployed CourseFlow frontend.
Testing
We created automated tests for:
Date extraction
Numeric, named, ordinal, and ISO date formats
Missing years
Duplicate removal
Same-day conflicts
Seven-day workload conflicts
Semester boundaries
Invalid semester settings
Rejected-event handling
ICS export
The backend currently passes 11 automated tests.
We also created a reproducible nine-fixture date-extraction benchmark.
Measured results from this small test set:
12/12 expected dates found
0 expected dates missed
1 documented false positive
92.3% date precision
100% date recall
These results are published with their limitations in the public repository. They are not intended as a claim of universal syllabus accuracy.
Challenges we ran into
Making date extraction trustworthy
Finding a date is not the same as understanding whether it is a real deadline.
For example:
“The previous exam was held May 12, 2025.”
contains a valid date, but it describes a historical event rather than a future deadline. Our benchmark intentionally includes this case, and CourseFlow currently extracts it as a possible event.
Instead of hiding this limitation, we designed CourseFlow to show the original source sentence and require student review before export.
Designing a clearer date editor
Our first version used small inline date fields. During manual testing, the date-editing experience was difficult to discover and understand.
We replaced it with a focused popup containing:
Clear labels
Calendar input
Event type
Effort estimate
Course
Save and Cancel actions
This made the editing workflow easier to understand.
Handling embedded preview restrictions
The original accuracy-report link did not open inside an embedded preview. We learned that important judging evidence should not depend entirely on external navigation.
We added an in-app benchmark popup explaining:
Precision
Recall
Tested formats
The known historical-date limitation
The complete report remains available in the public repository.
Deploying the frontend and backend
We initially considered using separate hosting providers, but one required payment-card verification. We instead adapted FastAPI for Vercel’s Python serverless environment.
The first API deployment returned Not Found because the Vercel rewrite did not preserve the original API path. We corrected the routing configuration, redeployed, and then tested both text and PDF processing in production.
Calendar downloads in embedded previews
The .ics download did not start inside the embedded development preview. We documented the issue and retested it after deployment in a normal browser, where the complete workflow could be tested properly.
Accomplishments that we're proud of
We are proud that CourseFlow is more than a static prototype.
The project includes:
A working deployed web application
A deployed FastAPI backend
Text and PDF syllabus processing
Human review before export
Manual deadline creation
Editable dates and effort estimates
Semester settings and boundary warnings
Same-day and seven-day conflict detection
ICS calendar export
Responsive design
Eleven passing automated tests
A reproducible accuracy benchmark
A public manual test log
A public GitHub development history
Clear documentation and known limitations
We are especially proud that feedback from manual testing directly changed the product. The confusing date editor and inaccessible external report were not ignored; both were redesigned and tested again.
What we learned
CourseFlow helped us learn how a complete web application works across multiple layers.
We learned:
How React state updates an interactive interface
How a frontend sends forms and files to an API
How FastAPI handles multipart PDF uploads
How PyMuPDF extracts text from documents
How common date formats can be parsed and normalized
How Pydantic validates structured data
How deterministic rules can detect workload conflicts
How the iCalendar format represents events
How automated tests reveal edge cases and limitations
How environment variables connect deployed services
How browser CORS protects API access
How to deploy a React frontend and FastAPI backend on Vercel
How manual user testing can improve interface design
Our most important lesson was that automated extraction should not be presented as perfect. A useful product should communicate uncertainty, show evidence, and let the user remain in control.
Current limitations
CourseFlow is a hackathon project with a focused scope.
Current limitations include:
It supports text-based PDFs, not scanned-image OCR.
Relative phrases such as “next Friday” are not converted into dates.
Historical dates can still appear as possible deadlines.
Effort estimates are initial defaults and should be reviewed.
Data is not persisted after the browser session.
CourseFlow exports a calendar file rather than directly accessing a private calendar account.
These limitations are documented so users and judges can understand exactly what the current version does.
What's next for CourseFlow
Future improvements could include:
OCR support for scanned syllabi
Multiple-course workspaces
Saved projects and persistent deadline history
Drag-and-drop workload balancing
A visual semester workload heatmap
Better duplicate-event review
More advanced historical-context detection
Additional date-language support
Direct calendar integrations with explicit user permission
Accessibility testing with more users and devices
A larger and more diverse syllabus benchmark
Our long-term goal is for CourseFlow to become a reliable student planning assistant that saves time while keeping students in control of every important deadline.
## AI Usage Disclosure
CourseFlow was developed with assistance from AI tools for brainstorming,
scaffolding, debugging, testing ideas, and documentation review. I directed the
project, made product and usability decisions, reviewed and tested the
implementation, configured deployment, resolved production issues, and verified
the final application. I understand and can explain the project’s core
architecture and behavior.
Log in or sign up for Devpost to join the conversation.