How the viva-voce works
The final year project viva is a face-to-face evaluation where a panel of two to four faculty members questions you about your project. It typically lasts 10-20 minutes and contributes 20-40% of your total project marks. The panel includes your project guide (internal examiner) and one or more external examiners from other departments or colleges.
Evaluators test three things: whether you understand the problem you solved, whether you can explain the technology you used, and whether you actually wrote the code yourself. The questions move from general to specific — starting with your project overview and drilling down into implementation details.
General project questions (asked in every viva)
These questions are asked regardless of your project domain or technology:
1. Explain your project in two minutes.
How to answer: Start with the problem, then your solution, then the technology used. Example: "My project is a disease prediction system that takes patient symptoms as input and predicts the most likely disease using a Random Forest classifier trained on a dataset of 5000+ records. The frontend is built with React, the backend with Django REST Framework, and the ML model uses scikit-learn."
2. What problem does your project solve?
How to answer: Be specific and quantifiable. Not "it helps people" but "it reduces diagnostic time from 20 minutes to under 30 seconds for common diseases, making preliminary screening accessible at primary health centers."
3. Why did you choose this topic?
How to answer: Connect it to a real-world need. "India has one doctor for every 1,500 patients. AI-powered preliminary screening can help bridge this gap, especially in rural areas where specialist access is limited."
4. What is the scope of your project?
How to answer: State what your project covers and does not cover. "The system currently predicts 15 common diseases based on symptom input. It does not replace medical diagnosis but serves as a preliminary screening tool."
5. Who is the target user of your project?
How to answer: Be specific about your user personas. "Primary users are patients who want preliminary health screening. Secondary users are healthcare workers at primary health centers who can use this as a triage tool."
6. What are the limitations of your project?
How to answer: Every project has limitations. Acknowledge them honestly. "The model accuracy is 92%, which means 8% of predictions could be incorrect. It only works with structured symptom data, not medical images. It requires internet connectivity."
7. What is the future scope of your project?
How to answer: Mention two to three realistic enhancements. "We could add medical image analysis using CNNs, integrate with electronic health records, and develop a mobile app for offline use."
8. How is your project different from existing solutions?
How to answer: Reference specific existing solutions and explain your differentiator. "WebMD and similar platforms use rule-based systems. Our project uses a trained ML model that improves with more data and provides probability-based predictions rather than deterministic outputs."
9. Explain the architecture of your project.
How to answer: Walk through your system diagram. "The frontend React app sends API requests to the Django backend. The backend processes the input, passes it to the ML model for prediction, and returns results. PostgreSQL stores patient data and prediction history. The entire system is containerized with Docker."
10. What challenges did you face during development?
How to answer: Mention real technical challenges. "The initial model had 78% accuracy due to class imbalance in the dataset. We used SMOTE oversampling to balance the classes, which improved accuracy to 92%. We also faced CORS issues when connecting the React frontend to the Django API, which we resolved with django-cors-headers."
Technology-specific viva questions
Python and Django questions
11. What is Django and why did you choose it?
Django is a high-level Python web framework that follows the MVT (Model-View-Template) pattern. I chose it because it includes an ORM for database operations, built-in admin panel, authentication system, and REST framework for building APIs. It is also the most widely used Python web framework with excellent documentation.
12. Explain the MVT pattern in Django.
MVT stands for Model-View-Template. The Model defines the database schema using Python classes. The View contains the business logic and handles HTTP requests. The Template renders the HTML response. Django's URL router maps URLs to the appropriate view function.
13. What is Django ORM?
ORM stands for Object-Relational Mapping. Django ORM allows you to interact with the database using Python code instead of raw SQL queries. Each model class maps to a database table, and model instances represent rows. You can perform CRUD operations, filtering, and joins using Python methods.
14. How does Django REST Framework work?
DRF extends Django to build RESTful APIs. It provides serializers to convert model instances to JSON, viewsets and routers for CRUD endpoints, authentication classes (Token, Session, JWT), and browsable API for testing. It handles pagination, filtering, and throttling out of the box.
15. Explain how authentication works in your project.
We use token-based authentication with Django REST Framework. When a user logs in with valid credentials, the server generates a token and returns it. The client stores this token and includes it in the Authorization header of subsequent requests. The server validates the token on each request.
Machine learning questions
16. What algorithm did you use and why?
We used Random Forest because it handles both numerical and categorical features, is resistant to overfitting compared to single decision trees, provides feature importance scores, and achieves high accuracy on tabular datasets. We also tested Logistic Regression, SVM, and XGBoost — Random Forest gave the best results on our validation set.
17. How did you handle the training-testing split?
We used an 80-20 split — 80% of the data for training and 20% for testing. We also used 5-fold cross-validation during model selection to ensure the results are not dependent on a particular split. The stratified split ensures equal class distribution in both sets.
18. What is overfitting and how did you prevent it?
Overfitting occurs when a model learns noise in the training data and performs poorly on unseen data. We prevented it by using cross-validation, limiting tree depth in Random Forest, using regularization, and ensuring our training dataset was large enough (5000+ samples).
19. Explain the confusion matrix for your model.
The confusion matrix shows True Positives (correctly predicted positive), True Negatives (correctly predicted negative), False Positives (predicted positive but actually negative), and False Negatives (predicted negative but actually positive). Our model achieves 92% accuracy with precision of 0.91 and recall of 0.93.
20. What preprocessing did you do on the data?
We handled missing values using median imputation, encoded categorical variables using Label Encoding and One-Hot Encoding, normalized numerical features using StandardScaler, and removed outliers using the IQR method. We also performed feature selection to remove low-importance features.
React and frontend questions
21. What is React and why did you use it?
React is a JavaScript library for building user interfaces. We used it because it uses a component-based architecture that makes code reusable, virtual DOM for efficient rendering, a large ecosystem of libraries, and strong community support. It is also the most popular frontend framework in job market terms.
22. Explain the difference between state and props in React.
Props are read-only data passed from parent to child components. State is mutable data managed within a component. When state changes, React re-renders the component. Props are used for component configuration and data flow. State is used for dynamic data like form inputs, toggle states, and API responses.
23. What is the virtual DOM?
The virtual DOM is a lightweight JavaScript representation of the actual DOM. When state changes, React creates a new virtual DOM tree, compares it with the previous one (diffing), and only updates the actual DOM elements that changed. This is faster than directly manipulating the DOM for every update.
24. How do you handle API calls in React?
We use the Axios library to make HTTP requests to the Django REST API. API calls are made inside useEffect hooks to fetch data when components mount. We manage loading states, error handling, and data storage using useState. For global state, we use React Context.
25. What is a React hook?
Hooks are functions that let you use state and lifecycle features in functional components. useState manages local state. useEffect handles side effects (API calls, subscriptions). useContext accesses context values. useRef accesses DOM elements. Custom hooks extract reusable logic.
Database questions
26. Why did you choose this database?
We chose PostgreSQL because it supports complex queries, has strong ACID compliance, handles concurrent connections well, supports JSON fields for flexible data, and integrates seamlessly with Django ORM. For our data volume (under 100,000 records), it provides excellent performance.
27. Explain the ER diagram of your project.
Walk through each entity (table), its attributes, and relationships. Example: "The User table has a one-to-many relationship with Predictions — each user can have multiple predictions. The Disease table has a many-to-many relationship with Symptoms through a junction table."
28. What is normalization? Is your database normalized?
Normalization is the process of organizing data to reduce redundancy. Our database follows Third Normal Form (3NF) — every non-key attribute depends on the primary key, the whole key, and nothing but the key. We have separate tables for users, diseases, symptoms, and predictions with foreign key relationships.
29. How do you handle database migrations?
Django manages migrations automatically. When we change a model, we run 'python manage.py makemigrations' to generate migration files and 'python manage.py migrate' to apply them. This version-controls our database schema changes.
30. What is indexing and did you use it?
Indexing creates a data structure that speeds up data retrieval on frequently queried columns. Django automatically creates indexes on primary keys and foreign keys. We added additional indexes on the email field (for login queries) and the created_at field (for sorting predictions by date).
Project management and process questions
31. What methodology did you follow?
We followed an Agile approach with two-week sprints. In each sprint, we planned tasks, implemented features, tested them, and reviewed progress. This allowed us to adapt to changing requirements and deliver working features incrementally.
32. How did you divide work among team members?
We divided work by module — one member handled the frontend (React), another the backend (Django), and the third member worked on the ML model and data processing. We used Git for version control and had daily standups to sync progress.
33. What version control system did you use?
We used Git with GitHub for version control. We followed the feature branch workflow — each feature was developed in a separate branch and merged into the main branch after code review. This prevented conflicts and kept the main branch stable.
34. How did you test your project?
We used unit testing with pytest for the Django backend, integration testing for API endpoints with Postman, and manual testing for the frontend. We wrote 30+ test cases covering all major features and edge cases.
35. How would you deploy this project?
For production deployment, we would use AWS EC2 with Nginx as a reverse proxy, Gunicorn as the WSGI server, and PostgreSQL on RDS. The React frontend would be built and served as static files. We would use HTTPS with Let's Encrypt and set up CI/CD with GitHub Actions.
Advanced questions (for BTech and MCA vivas)
36. What design patterns did you use?
We used the Repository pattern for data access, the Singleton pattern for database connections, the Observer pattern for real-time notifications, and the Factory pattern for creating different prediction models based on the disease category.
37. How do you handle security in your project?
We implemented input validation and sanitization to prevent SQL injection and XSS, CSRF protection using Django's middleware, password hashing with bcrypt, rate limiting on API endpoints, and HTTPS for data in transit. Sensitive configuration values are stored in environment variables.
38. Explain the API endpoints of your project.
Walk through your major endpoints: POST /api/auth/login (user authentication), GET /api/predictions (list user predictions), POST /api/predict (submit symptoms and get prediction), GET /api/diseases (list all diseases). Explain the request format, response format, and status codes.
39. How would you scale this project for 10,000 users?
We would add a load balancer (AWS ALB), implement database connection pooling, cache frequently accessed data with Redis, use a CDN for static assets, and set up horizontal scaling with multiple application server instances behind the load balancer.
40. What would you do differently if you started over?
This is a trick question — the evaluator wants to see self-reflection. Be honest about what you learned. Example: "I would spend more time on system design before coding, use TypeScript instead of JavaScript for type safety, and write tests from the beginning instead of adding them later."
Preparing for your viva
- Read your own report — evaluators reference it during questions. Know every section.
- Run your project before the viva — test it the night before. Make sure it works.
- Know your code — be able to explain any function in your project. If you used a library, know what it does.
- Prepare a 2-minute project overview — this is always the first question. Practice it.
- Dress formally — it sets a professional tone.
- Say "I don't know" honestly — if you do not know an answer, say so. Guessing wrong is worse than admitting ignorance.