Discussion: Backend/Frontend Integration for Assignment and Quiz Management UI

[Jose-Alarcon1]

📢 Discussion: Backend/Frontend Integration for Assignment and Quiz Management UI

Context

The Assignment and Quiz Management UI has been implemented and merged into main. The interface enables tutors to:

• View a list of assignments
• Create/edit assignments with fields such as title, type, deadline, and optional upload
• Add quiz questions supporting multiple formats (Multiple Choice and Short Answer)
• View a list of questions in a quiz alongside their solutions

The frontend currently uses mock data for testing, but is structured in alignment with the expected backend schema. All views and form logic are encapsulated within a single AssignmentCreate.jsx component and styled modularly through AssignmentCreate.css.

🔧 Backend Preparation

Based on the Django models for Assignment, Quiz, Question, Choice, and Solution, we are looking to align frontend data handling with backend expectations. Below are key items requiring clarification:

Assignment

• Fields used: title, description, assignment_type, deadline, student (nullable), upload_record (nullable)
• Open Question: Should the student_id be included in the POST request during assignment creation, or should the association happen afterward?

Quiz

• Related to: A single assignment
• Fields: assignment, num_of_questions, attempts, time_limit (optional)
• Open Question: Should the quiz be created immediately after the assignment is posted, or through a separate manual POST request?

Question

• Fields: quiz, question_type, order_of_question, question_text, points
• Open Question: Should the frontend manually assign order_of_question, or will the backend auto-increment this?

Choice

• Frontend generates an array of choice_text and is_correct values for MC questions
• Open Question: Can the frontend send a bulk array of choices in the question POST, or must each choice be posted separately using a dedicated /choices/ endpoint?

Solution

• MC Questions: Selected choice IDs are captured
• SA Questions: A short_answer_text is included
• Open Question: Can solutions be embedded directly in the question POST, or must they be PATCHed to the question after it's created?

❓ Key Questions for the Team

• What is the preferred endpoint structure for chaining assignment → quiz → questions → choices/solutions?
• Will the backend support nested object creation (e.g., one POST for quiz including nested questions and choices)?
• Should we support editing and deletion of individual questions and choices in this initial API phase?
• Are there validation rules around certain fields (e.g., student, upload_record, or assignment_type combinations)?
• Will there be permission enforcement (e.g., tutor-only access for creation and updates)?

💬 Let Us Know

• Expected request/response shapes for each object (Assignment, Quiz, Question, Solution)
• Whether solution data (choices or short answers) should be handled within the question payload or separately
• Whether question.order_of_question is critical, or if the backend will determine ordering
• Your recommended flow:
  Assignment → Quiz → Questions → Choices → Solutions

Looking forward to aligning frontend and backend more closely in the next iteration. Let me know if example payloads or diagrams would help solidify expectations.

Related PR: #155
Please check out this PR to see the screenshots taken of the current website. and to see the flow of the pages with the constructed UML

[AbdulAlharbi]

Hey Jose, thanks for the detailed breakdown—super helpful!

The UI looks great so far, and I really appreciate how you laid out each backend integration point clearly.

Here are my quick thoughts on the open questions:

• For student_id, it might be cleaner if that association happens after creation, especially since it's optional—this keeps the initial POST simpler.
• I’d vote for keeping quiz creation as a separate POST. It gives tutors flexibility in managing assignments and quizzes independently.
• Auto-incrementing order_of_question on the backend would prevent any conflicts if multiple users are adding questions at once.
• If possible, supporting bulk choice creation in one POST sounds ideal—it would really reduce the number of API calls we have to manage.
• For solutions, maybe patching them after question creation makes the flow clearer and gives more control over editing.

As for the flow, your suggested chain of Assignment → Quiz → Questions → Choices → Solutions feels intuitive and easy to manage. Also +1 to having permission checks in place from the start.

Let me know if we want to sync on payload examples—I’d be happy to help flesh those out! 🔧

Thanks again for kicking this off so thoughtfully!
Abdulrahman

[aviendha-andrus]

Hi Jose!
I love the questions, this is a really in depth exploration of the communication necessary between back and front end. Thank you for implementing the frontend and inquiring about the groups opinion about changes moving forward.

Should the student_id be included in the POST request during assignment creation, or should the association happen afterward?

I don’t think it should be associated, and that the student should be assigned after. This would make it easier for tutors to reuse assignments.

Should the quiz be created immediately after the assignment is posted, or through a separate manual POST request?

I think it should be created with a separate manual POST request, for the situation where an assignment doesn’t have a quiz.

Should the frontend manually assign order_of_question, or will the backend auto-increment this?

I think the backend should auto-increment this, maybe implement a randomized order even? Frontend should be able to edit the order but maybe initially incremented would be best.

Can the frontend send a bulk array of choices in the question POST, or must each choice be posted separately using a dedicated /choices/ endpoint?

An array of choices (like a, b, c, d) would be convenient but ultimately is not essential.

Can solutions be embedded directly in the question POST, or must they be PATCHed to the question after it's created?

It would add complexity to embed it, a PATCH makes more sense.

Let me know if you need anything else from a backend perspective!

[ChrisCRL]

Hey Jose! Here are my thoughts regarding your key questions for the team:

1. Endpoint Structure

• /assignments/ → /assignments/{id}/quiz/ → /quiz/{id}/questions/ → /questions/{id}/choices/

2. Nested Object Creation

• Quiz with questions in one POST operation
• Keep choices as separate POSTs for flexibility

3. Editing Support

Priority Order:

• Full CRUD for assignments and quizzes
• Question editing capability

4. Validation Rules

Field-Specific Rules:

• assignment_type: Enforce type-specific validations (quiz vs upload requirements)
• student: Optional during creation, required before publishing
• upload_record: Required only for assignment types that need uploads

5. Permission Enforcement

Implementation:

• Tutor-only middleware for all creation/edit endpoints
• Consider view-level permissions for students vs tutors

[Jose-Alarcon1]

Thanks @AbdulAlharbi!

Really appreciate your thoughtful feedback and for helping clarify these backend integration points. Your input definitely brings more structure to how we move forward with connecting everything.

• ✅ I agree on deferring student_id association until later—it keeps things cleaner for initial creation.
• ✅ Keeping quiz creation as a standalone step also makes a lot of sense—modularity helps both UX and error handling.
• ✅ Auto-incrementing order_of_question backend-side is a great call—will save us edge cases and sync headaches.
• ✅ Bulk POST for choices is ideal—will structure frontend to align with that and test with mock handlers in the meantime.
• ✅ And yep, separating solution PATCH after question creation gives clearer logic both frontend and backend.

Sounds like we're aligned on the core flow (Assignment → Quiz → Questions → Choices → Solutions), and I’ll make sure permission guards are top-of-mind in the next iteration.

Let’s definitely sync on example payloads soon—I’ll start drafting a few and will loop you in once I have a baseline ready to review together.

Thanks again for helping shape this integration roadmap. Looking forward to shipping a really clean experience end-to-end!

[Jose-Alarcon1]

Thanks @aviendha-andrus

Really appreciate your detailed responses and backend perspective—it’s incredibly helpful to align on this before moving forward with implementation.

• ✅ Deferring student_id makes perfect sense—great point about reusability for tutors.
• ✅ Keeping quiz creation separate is totally reasonable for flexibility—I'll structure the form logic accordingly.
• ✅ Love the idea of backend auto-incrementing order_of_question with possible randomized order support. Will plan for a frontend interface that allows reordering in the future.
• ✅ Got it on the choices array—will aim to support it in bulk for simplicity, but fallback to individual posts if needed.
• ✅ Totally agree that separating solutions with a PATCH makes the logic cleaner—I'll make sure it's handled as a separate interaction.

Thanks again for weighing in! Your insights make the backend/frontend handoff much smoother. I’ll sync again once I start wiring up real API endpoints and will keep you posted if I hit any edge cases or need clarification on response formats.