CSC4900 asks students to do the part of software engineering that's easy to skip in coursework: rigorously planning and designing a project before writing a significant line of code, so that CSC4902's implementation phase builds on a solid foundation rather than a vague idea.
Capstone project scoping and requirements definition
CSC4900 begins with project selection and scoping — choosing a project ambitious enough to demonstrate genuine CS competency but scoped realistically for a single-term implementation timeline, a balance many students get wrong in either direction. Students write a formal requirements document defining functional requirements (what the system must do), non-functional requirements (performance, security, usability constraints), and explicit out-of-scope boundaries to prevent scope creep during implementation.
System design and architecture planning
The course covers system design deliverables — architecture diagrams, database schema design, API design, and technology stack selection — that CSC4900 produces as the blueprint CSC4902 will implement against. Students practice justifying design decisions (why this database, why this architecture pattern) rather than making technology choices arbitrarily, since a capstone committee will expect design decisions to be defensible, not just functional.
Key topics in CSC4900
- Capstone project selection and appropriately scoping project ambition to timeline
- Requirements definition: functional requirements, non-functional requirements, and scope boundaries
- System architecture design: architecture diagrams and design pattern selection
- Database schema design and API design planning
- Technology stack selection and justification
- Project planning: timeline, milestones, and risk identification for the implementation phase
Working on a capstone requirements document or a system design plan?
Our computer science experts build CSC4900-level coursework with genuine software engineering planning rigor.
Worked example: scoping a capstone project appropriately
- Overambitious scope: "Build a full social media platform with real-time messaging, video, and a recommendation engine" — unrealistic for a single-term undergraduate capstone
- Appropriately scoped: "Build a web application for local community event discovery, with user accounts, event posting, search/filter, and basic recommendation based on user-selected interest tags"
- Why it works: Demonstrates full-stack competency (auth, database, search, basic recommendation logic) within a realistic implementation timeline, with clear, testable functional requirements
- Lesson: A strong capstone project demonstrates depth and correct engineering practice on a properly scoped problem, not breadth on an unrealistic one
Get Help With CSC4900
Capstone requirements documents and system design assignments.
Place Your OrderView All ServicesRelated courses
Frequently asked questions
In professional software engineering, inadequate upfront planning is one of the most common causes of project failure — requirements that are discovered mid-implementation rather than defined upfront lead to costly rework, scope creep, and architecture decisions made under time pressure rather than deliberate consideration. CSC4900 dedicates a full course to planning specifically to instill this discipline before students enter a professional environment where skipping proper requirements and design work is expensive and visible. It also serves a practical pedagogical purpose: a capstone committee evaluating CSC4902's final implementation needs a clear requirements and design baseline to assess against — without CSC4900's documented plan, there's no way to evaluate whether the final CSC4902 deliverable actually met its original goals or whether the goals simply shifted to match whatever got built.
The right scope balances two competing pressures: the project must be ambitious enough to genuinely demonstrate the technical competencies expected of a graduating CS student (not a trivial exercise), but realistic enough to be fully implemented, tested, and documented within the actual time available, typically a single term. CSC4900 teaches students to scope by identifying a small number of core features that together demonstrate meaningful technical depth (e.g., user authentication, a non-trivial data model, a genuine algorithmic or search component) rather than a long list of surface-level features that would each be implemented shallowly. A useful diagnostic question the course encourages is: "if I only had time to build half of what I'm planning, would the remaining half still be a coherent, demonstrable project?" — if the answer is no, the scope is likely too ambitious and needs to be narrowed before implementation begins in CSC4902.