Oregon State CS 361: Software Engineering I
CS 361 introduces software engineering practice — requirements, agile processes, design principles, version control workflows, and a term-long team project built in sprints. It's the course where the program stops grading programs and starts grading how software gets built by groups of humans.
Fennie is independent and not affiliated with Oregon State University. This is an unofficial study guide.
Build my CS 361 study planWhat makes it hard
The challenge is the team: sprints with four or five working adults across time zones, where your grade partially rides on collective output and the process artifacts — user stories, reviews, sprint documents — are graded work, not overhead. Students expecting a coding course are blindsided by how much of the grade is communication, coordination, and writing.
What you'll cover
- • Agile development and sprints
- • Requirements and user stories
- • Software design principles
- • Git workflows and code review
- • Team communication and documentation
The CS 361 study guide
How to study for Oregon State CS 361, step by step.
- 1
Treat process artifacts as graded deliverables
User stories, sprint plans, and reviews carry real points in CS 361. Write them with the same care as code — they're the course's actual subject.
- 2
Establish team rhythms in the first week
Standup cadence, channel, time-zone overlap windows, and a norm for surfacing blockers early. Teams that skip this spend week five discovering why it existed.
- 3
Make your contributions visible and steady
In team grading, invisible work is ungraded work. Commit regularly, write up what you did each sprint, and keep your share of the board moving.
- 4
Learn the Git workflow cold before the project needs it
Branches, pull requests, merge conflicts — practiced solo, before a teammate's deadline depends on your merge. Git fumbles under pressure are the course's most avoidable crisis.
- 5
Sync your half with Fennie
Upload your CS 361 syllabus and Fennie's Daily Plan slots sprint deliverables and reading into daily sessions around your job, with quizzes on the process concepts generated from your actual course materials. Free to start.
Start my CS 361 plan free
How Fennie helps with CS 361
Fennie's Daily Plans keep your half of CS 361's team bargain — sprint deliverables, readings, and exam prep scheduled around work so you're never the blocker. Use chat to sharpen user stories and design docs before the team sees them, and quiz yourself on the agile and design vocabulary the assessments draw from.
FAQ
Is CS 361 hard in the OSU postbacc?
Rarely technically — the difficulty is coordination. Team sprints across time zones with everyone employed full-time is the genuine curriculum, and the students who thrive treat communication as part of the job rather than friction around it.
How are teams chosen in CS 361?
Typically assigned or formed early in the term, varying by instructor. Either way, the highest-leverage move is identical: establish meeting rhythm, channels, and blocker norms in week one, because the sprint clock starts immediately.
What's the difference between CS 361 and CS 362?
361 is building software as a team — process, requirements, design, sprints. 362 turns to verifying it: testing strategies, unit tests, coverage, and CI. They're designed as a sequence, and the 361 project habits carry directly into 362.
Pass CS 361 with a plan, not a cram
Upload your CS 361 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore Oregon State courses
CS 161 — Introduction to Computer Science I
CS 161 is Oregon State's first programming course — variables, control flow, functions, basic data structures, and program design — currently taught in Python after the curriculum moved away from C++. It opens both the Corvallis CS degree and the Ecampus postbacc, where for many students it's the first code they've ever written.
CS 162 — Introduction to Computer Science II
CS 162 continues the intro sequence — object-oriented programming, recursion, basic data structures, and significantly larger programs, taught in Python like CS 161. It carries a reputation as the Ecampus program's first real filter: the course where assignment scope jumps and time management becomes the curriculum.
CS 225 — Discrete Structures in Computer Science
CS 225 is the CS department's discrete math course — logic, proofs, sets, functions, combinatorics, and graphs — required in the Ecampus postbacc and a prerequisite mindset for CS 325. For career changers from non-quantitative fields, it's often the first proof-based math they've ever faced.
CS 261 — Data Structures
CS 261 covers the core data structures — dynamic arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs — with implementation assignments and complexity analysis throughout. In the Ecampus postbacc it's taught in Python (older blog posts reference the earlier C version), and it's the technical-interview foundation for the whole program.