Theory
How the project is marked
Finally, know how your project will be judged, because that tells you where to put your effort. The syllabus gives an explicit evaluation scheme: the marks are spread across six areas, from planning right through to the presentation.
The headline lesson is important: marks are not only for the code. Every stage you have studied, planning, design, testing, documentation, presentation, carries marks. This closing lesson lays out the scheme so you can invest your effort where the marks are. Understanding it helps you avoid the classic mistake of pouring everything into coding while neglecting the stages that together are worth more.
At a glance
| Area | Weight |
|---|---|
| Problem definition and planning | 10 percent |
| Design and architecture | 15 percent |
| Implementation and functionality | 30 percent |
| Testing and deployment | 15 percent |
| Documentation | 10 percent |
| Final presentation and viva | 20 percent |
Theory
Reading the scheme
The six weights add up to 100 percent: 10 + 15 + 30 + 15 + 10 + 20 = 100.
Implementation and functionality is the single largest slice at 30 percent, the working software matters most, as you would expect. But look at the rest: the other five areas together are worth 70 percent. Design and architecture (15) and testing and deployment (15) are each half as much as implementation; the final presentation and viva is a substantial 20 percent; and even planning (10) and documentation (10) carry real marks.
So the message is clear: do every stage well. A brilliant implementation with no design, no testing, poor documentation, and a fumbled presentation leaves most of the marks on the table. Balance your effort across the whole project. (Confirm the exact scheme with your institute, as details may vary.)
Quiz
In the BCA604 evaluation scheme, implementation and functionality is worth 30 percent. What does this imply about the other stages?
- The other stages are worth nothing; only implementation matters
- The other five areas together are worth 70 percent, so planning, design, testing, documentation, and the presentation all carry significant marks and should be done well
- Only the presentation matters
- Implementation is worth 100 percent
Show the answer
The other five areas together are worth 70 percent, so planning, design, testing, documentation, and the presentation all carry significant marks and should be done well
Implementation and functionality is the largest single area at 30 percent, but the other five areas, problem definition and planning (10), design and architecture (15), testing and deployment (15), documentation (10), and final presentation and viva (20), together add up to 70 percent, so the majority of marks lie outside implementation. Option A is wrong and is the classic mistake: neglecting planning, design, testing, docs, and presentation throws away most of the marks. Option C is wrong: the presentation is 20 percent, important but not the only thing. Option D contradicts the scheme (implementation is 30, not 100). The lesson: do every stage well, because most of the marks are spread across the whole process, not just the code.
Think first
Why does the evaluation scheme reward the whole process, not just the working code?
Surely a working project is what counts. Why give most of the marks to planning, design, testing, docs, and presentation? Then tap.
Show the answer
Because a final-year project assesses your ability to do software ENGINEERING as a complete discipline, not just to produce a program, and real engineering is the whole process, understanding a problem, planning, designing, building, testing, documenting, and communicating, so the scheme rewards all of it to reflect what genuine professional competence actually requires. Producing working code is necessary but not sufficient. In the real world, a developer who can only code, but cannot analyse a problem, design a sound structure, test rigorously, document clearly, or explain their work, is of limited value and even dangerous, because unplanned, untested, undocumented, uncommunicated software fails, breaks, and cannot be maintained. The stages the scheme rewards are exactly the professional practices that separate reliable engineering from mere hacking: PLANNING and problem definition ensure you build the right thing; DESIGN ensures it is structured to work and to grow; TESTING and deployment ensure it actually works and reaches users; DOCUMENTATION ensures it can be understood and maintained; and the PRESENTATION and VIVA ensure you can COMMUNICATE and DEFEND your work and truly understand it. By allocating marks across all of these, the scheme signals that the project is testing you on the FULL competence, and it steers you to practise every part rather than obsessing over code alone. This mirrors reality: implementation is the biggest single slice (30 percent) because working software is central, but the majority (70 percent) lies in the surrounding process because that process is what makes software professional rather than a fragile one-off. It also protects against the common failure mode where a student pours all their effort into features and neglects everything else, then loses marks (and, in industry, would deliver an unmaintainable, unexplained system). So the scheme is not arbitrary bureaucracy; it is a deliberate reflection of what good software engineering is, a whole disciplined process, and doing every stage well is both how you score well AND how you become a capable engineer. The whole process is the skill, so the whole process is marked, which is exactly why you should do all of it well. Engineering is more than code, and the scheme rewards the whole of it.
Theory
BCA604 complete: the capstone method
You now have a full methodology for your final-year project: define the problem, check feasibility and requirements, choose a fitting stack, schedule and assign roles, design the system, database, and interface, build the front end and back end, integrate and test, document, deploy, report, and present. And you know the marks span the whole process, so do every stage well. This is the professional way to build software, and the project is your chance to prove you can. Plan it, build it, and present it with pride. Good luck.
Summary
Key takeaways
- The BCA604 evaluation scheme spreads marks across six areas summing to 100 percent.
- Problem definition and planning: 10 percent; design and architecture: 15 percent; implementation and functionality: 30 percent.
- Testing and deployment: 15 percent; documentation: 10 percent; final presentation and viva: 20 percent.
- Implementation is the largest single area (30), but the other five together are worth 70, most of the marks.
- So do every stage well: planning, design, testing, documentation, and presentation all carry significant marks.
- The scheme rewards the whole engineering process because that whole process is the competence being assessed; confirm exact details with your institute.
- Memory hook: 10 planning, 15 design, 30 implementation, 15 testing/deploy, 10 docs, 20 presentation/viva, every stage counts.