The course families covered
- Gateway scripting in IT 140, where the project assembles across the modules and the commentary is graded next to the code.
- The software engineering spine, including the testing artifacts in CS 320: plans, cases and summary reports in the form industry actually uses.
- Full stack builds in CS 465, milestone by milestone from wireframe to working application.
- Security foundations in CYB 200, where vocabulary precision is the difference between two bands.
- The data and statistics layer, MAT 240 included, where the output and the interpretation have to agree.
Why the portfolio changes the stakes
These programs are built so that classwork becomes portfolio evidence, and later courses ask you to curate and reflect on artifacts from earlier ones. That architecture punishes survival-mode work twice: a barely-passing project resurfaces months later, unimproved, in front of a rubric asking you to showcase it.
So builds here are written to portfolio grade the first time. Clean structure, honest documentation, decisions that can be explained out loud. The second audience for this code is a hiring manager, and that audience has no revision policy. Where a later course asks you to revisit an old artifact, send the original and the improvement is written against what is actually there.
How code milestones compound
Prose milestones can be patched. Code milestones calcify: a schema or an architecture chosen badly in Module Two taxes every module after it, and the final submission inherits the debt. Bought as an arc, the whole build stays with one engineer from the first design document to the last artifact, which is the difference between a coherent project and four assignments sharing a file name.
Where a course asks you to reflect on your own process, the delivery includes a walkthrough, so what you write about the work is genuinely yours to say.
The writing layer computing students skip
Every computing course carries prose that engineers in training deprioritize: weekly threads, reflection assignments, security policy write-ups, requirements documents that read as paperwork until the rubric shows how many points they hold. Those pieces are usually where a strong builder quietly loses a letter grade.
They are also the cheapest things to hand over, because they are short and their criteria are explicit. A term where the code stays yours and the documentation is drafted here is a common arrangement and often the right one, particularly in the security courses, where the grade turns on using the vocabulary exactly and consistently rather than on building anything at all.
The other quiet cost is the thread in a technical course, where the expectation is a substantive point about a design decision rather than a summary of the reading. Those get written the way any deliverable does, to the criteria, in a voice that sounds like somebody who writes code. Threads across a whole term are quoted on the discussion page.
Sending a computing course over
Intake wants the course code, the spec or instructions, the rubric document and any starter files the course supplies. Say which language and version the class requires, because Python and the Python your grader runs are occasionally different things. Work returns as the artifact plus the write-up, in your personal email, for you to commit and submit yourself. Single deliverables are quoted on the assignment page, and how it works covers the sequence.
Send it over
Questions students ask first
Does the code actually run?
Yes, it is executed against the spec before it ships. A write-up describing behavior nobody produced is the fastest way to fail a testing course.
Can you match a required language or framework?
Send what the course mandates, versions included. Work is written to that stack rather than to whatever is currently fashionable.
Will the documentation match the rubric?
That is the half students lose most points on, so it clears the same rubric check as any paper: criterion by criterion, at the verb depth the top band asks for.
Do you commit the work to my repository?
No. Files are delivered to your personal email and you push and submit them yourself. No account access is taken at any point.
What about a timed coding quiz?
Not covered. Written deliverables and build artifacts only; nobody here sits a timed or proctored assessment.
Can you help me explain the project afterwards?
Ask for the walkthrough at intake. It exists so you can answer questions about design choices in a discussion thread or an interview.