This manual is for CSC-FPX4902 Assessment 1, start to submission. Assessment 1 in CSC-FPX4902, Computer Science Capstone 2, is usually where you account for what actually exists: the delivered system described as built rather than as designed, how it starts, what it depends on, and a test plan that keeps the levels of testing apart and says what each one covers. Claims here are expected to point at something a reader could verify. Below is the order our tutors report in, a section plan the criteria set, and one annotated excerpt. Prefer to hand it over? An original premium sample assembled from your own evidence returns inside 24 to 48 hours, rewritten free until the guide is met. Your courseroom may print this as CSC FPX 4902 Assessment 1 or CSC4902 Assessment 1; it is the same deliverable, and CSC-FPX4902 Assessment 1 is what this manual walks through.
One honesty note before the manual: Capella revises courses and scoring guides over time, so always write to the exact scoring guide attached to your assessment in the courseroom. The course identity above is verified on capella.edu; the method and structure below are our tutors' approach to it, not Capella's official rubric text.
How CSC-FPX4902 Assessment 1 is scored
Each criterion in the guide is placed at one of four levels and marked without reference to the others. On an account of a delivered system they mean roughly this:
| Level | What it means on a delivered system and test plan |
|---|---|
| Distinguished | The system is described exactly as it exists, with start-up steps somebody could follow without help, and the three levels of testing are kept distinct with a stated purpose and scope for each. What was not built is named in the same voice as what was. |
| Proficient | An accurate description and a test plan covering the levels. Complete, with the levels described together rather than separated by purpose. |
| Basic | The system described as the proposal imagined it, and testing treated as one undifferentiated activity. The commonest failure in a final report, and the most expensive. |
| Non-performance | A required element is absent, most often the setup or dependency account, or any distinction between test levels. |
Let the code tell you what to write. Read through what is actually committed, make a list, and describe the list. That hour of inventory is the cheapest insurance against the most expensive mistake available here, which is reporting the system you meant to build.
The CSC-FPX4902 Assessment 1 method, step by step
-
Criteria into headings, then inventory the repository
Go through the code as it stands and write down what is there: the modules, what each does, and what is missing relative to the proposal. That inventory is the factual base for every claim in the document, and it takes about an hour.
-
Describe how somebody else would run it
Prerequisites, the commands in order, the configuration values needed, and what a reader would see when it works. Then have somebody follow the steps on a clean machine if you possibly can, because setup instructions written from memory are wrong more often than they are right.
-
List the dependencies with versions and licences
Every framework, library, and service, with the version you built against and the licence it carries. A behavior reported with no version attached cannot be reproduced by anyone, and the licence column is what a criterion about legal considerations goes looking for.
-
Separate the three levels of testing and say what each is for
A unit test holds one function to known inputs and settles whether it computes what you claim. An integration test asks whether two parts still agree after being joined, and on a project built by one person that seam is where the defects gather. An acceptance test answers a numbered requirement from the proposal, one case per requirement. Give all three a purpose, a scope, and the environment they ran in.
-
Name the boundary of the test effort
Say what is not covered and why: the paths that need hardware you do not have, the volumes you could not reach, the third-party service you stubbed. A stated gap is a decision, and a gap the evaluator finds is a discovery.
-
Draw the line between your work and everyone else's, then self-score
Say what you wrote and what you configured, and attribute any borrowed or generated fragment in the code and again in the report. Then mark yourself criterion by criterion and rewrite whatever sits below the top level.
A structure that maps to the criteria
The lengths below are our tutors' planning targets for this part of a final report, not Capella limits; grow whichever section your guide weights heavily.
| Section | What it must do | Guide |
|---|---|---|
| The delivered system | What was built, module by module, described as it exists rather than as it was planned. | ~300 words |
| Running it | Prerequisites, commands in order, configuration, and what a working start looks like. | ~250 words |
| Dependencies | Every library and service with its version and licence, and what each contributes. | ~200 words |
| Test plan | The three levels, the purpose and scope of each, and the environment they ran in. | ~350 words |
| Test boundary and attribution | What was not covered and why, plus the line between your code and borrowed code. | ~250 words |
| References | Testing standards, dependency documentation with versions, professional conduct sources, current APA. | as needed |
Annotated sample excerpt
A model excerpt written by our team, included to show a test plan separated by purpose. Write yours on the same lines.
What exists is three parts: an importer that reads the co-op's daily job list as a comma-separated file, a sequencer that orders the stops for one rider, and a printable route sheet, with no rider mobile view, which was in the proposal and is reported as not built.1 Testing runs at three levels for three different reasons: 61 unit tests hold the sequencer's distance and ordering functions against known coordinates, 14 integration tests confirm that a file the importer accepted produces a sequence the route sheet can render, and 22 acceptance cases answer the numbered requirements from the proposal, one case to a requirement.2 Two boundaries are stated rather than left to be found: nothing was tested above 40 stops in one route because no real job list has exceeded 31, and the mapping service is stubbed in every automated test with recorded responses, so the suite proves the sequencer and not the service.3
- 1Lists what is there and volunteers what is not, in the same sentence and the same tone. The report is now describing the system as built.
- 2Gives each test level a count and a purpose, which is what keeps them distinct on the page. A criterion about test planning is looking for exactly this separation.
- 3Names two limits of the test effort with a reason for each. Stated gaps are decisions; discovered gaps are findings against you.
The full premium sample for your exact assessment, written fresh to your scoring guide and issue, is free to request. Study it, revise it into your own voice, and submit work you understand.
The five mistakes that cost Distinguished
- The system described as designed. A report about the intended build rather than the real one is the most expensive error available here.
- Setup steps written from memory. Instructions nobody has followed on a clean machine are usually wrong, and a grader may be the first to try.
- Testing treated as one activity. Unit, integration, and acceptance answer different questions, and the criterion expects them apart.
- Dependencies with no versions. Behavior described without a version cannot be reproduced by anybody, including you.
- Borrowed code left unattributed. In a capstone this stops being a formatting matter and becomes an integrity one.
Pre-submission checklist
- An inventory of the repository done before any prose was written
- The system described as built, with anything unbuilt named explicitly
- Setup steps a reader could follow on a clean machine, ideally tested by somebody else
- Every dependency listed with version and licence
- Unit, integration, and acceptance testing separated, each with purpose, scope, and environment
- Test boundary stated, borrowed fragments attributed in code and report, APA reconciled both ways
Final report due and the build is not what the proposal said?
Send the repository, the proposal, and the criteria. Back comes the honest account of the delivered system, setup steps somebody could follow, the dependency table, and a test plan with the three levels kept apart, inside 24 to 48 hours with revisions free until the guide is met. The first request is free.