Skip to content

Software Project Management

A free, complete, self-study course in software project management — written for undergraduate Computer Science and Data Science students, and for independent self-learners who want to understand how real software work is planned, organised, and delivered.

You can work through the whole course on your own. Every module has a lesson and at least one practical lab, and the course finishes with a capstone project you plan and deliver yourself. Self-check quizzes are written for the foundations modules so far, with the rest being added — the Self-Assessment page lists exactly what exists today and what is planned. No instructor is required. No software needs to be installed.

At a glance

  • Level: Undergraduate — no prior management experience assumed
  • Prerequisites: One software development course, or equivalent coding ability
  • Length: 13 modules · 16 weeks · 32 sessions · about 125 hours in total (64 hours of sessions, roughly 40 hours of labs, plus reading and the capstone)
  • Cost: Free
  • Assessment: Self-check quizzes and self-marked labs

What is software project management?

Software project management is the discipline of planning, coordinating, and controlling the work of building software so that it delivers real value to the people who need it, within acceptable limits of time, cost, scope, and quality.

It is not administration. It is the set of decisions that determine whether a good team succeeds: what is in scope, what order the work happens in, how long it will take, what could go wrong, who needs to know what, and — when reality differs from the plan — what to do about it. Engineers who understand this become far more effective, because they can see their work in context.

This course teaches both predictive (plan-driven) and adaptive (agile) approaches, because real teams use both, and usually combine them.

Who this course is for

  • You can already write software

    A single programming course is enough. If you can build and test a small program, you are ready.

  • You are an undergraduate or self-learner

    Computer Science, Data Science, Software Engineering, or anyone teaching themselves.

  • You are about to work on a team project

    Final-year projects, internships, hackathons, or a first job — this is the context you are missing.

  • You have no management experience

    Every concept starts from first principles. Nothing is assumed.

This course is not for you if you want a certification, a specific commercial tool, or a substitute for real experience on a real project. See Start Here for an honest account of what the course does and does not do.

What you need

Requirement Detail
Software background One software development course, or equivalent
Prior management experience None — this is an entry-level course
Tools A text editor and a spreadsheet. Nothing to install
Time ~7–9 hours per week for a term, or your own pace

What you will learn

By the end of the course you will be able to:

  1. Explain what a software project is, and how projects, programmes, and portfolios relate.
  2. Initiate a project: build a business case, write a charter, and analyse stakeholders.
  3. Plan across scope, schedule, cost, quality, risk, resources, and communication.
  4. Choose between predictive and adaptive delivery, and justify the choice.
  5. Build the core artefacts — charter, WBS, schedule, budget, risk register, RACI, and status report — using the course templates.
  6. Measure progress and take corrective action when the project deviates.
  7. Work effectively in a team: communicate, negotiate, and manage conflict.
  8. Deliver a small end-to-end software project as your capstone.

The Syllabus sets these out in full, and the Skills Progression Map shows how they build level by level.

How to use this course

If you are starting from zero, do these three things in order:

  • Read Start Here

    What the course covers, what you need, and how to study it effectively.

    Start Here

  • Skim the Learning Path

    What to study first and why, so you never start in the wrong place.

    Learning Path

  • Begin Module 01

    Foundations of Software Project Management.

    Course Content

Then track your progress as you go with the Progress Guide, which gives you a checklist for every module, the six capstone milestones, and the artefacts to keep — and follow the Semester Calendar to see what belongs in each of the 16 weeks.

Study in order

The modules build on one another. Skipping the foundations is the single most common reason people find the later material confusing — see why this order and not another.

Course modules

Thirteen modules in five parts, from foundations to an end-to-end capstone.

Part Modules Sessions What it covers
I — Foundations 01 · 02 · 03 S1–S7 Projects and life cycles, initiation and stakeholders, integrated planning
II — Agile & Adaptive Delivery 04 S8–S10 Agile values, Scrum, Kanban and flow
III — Planning Knowledge Areas 05 · 06 · 07 · 08 · 09 · 10 S11–S21 Scope and requirements, scheduling, estimation, risk, quality, teams and communication
IV — Control & Advanced Practice 11 · 12 S22–S29 Metrics and control, change management, procurement, documentation, distributed teams, ethics, closure, governance
V — Capstone 13 S30–S32 Plan and deliver an end-to-end project

The session-by-session plan is in the Curriculum Roadmap, and the Semester Calendar maps the same 32 sessions onto 16 weeks with lab windows and checkpoints.

How you will learn

This is a practical course. Each module pairs ideas with artefacts you actually produce.

flowchart LR
    accTitle: The study loop for each module
    accDescr {
    Reading the lesson leads to doing the lab, studying the case and taking the quiz. If the quiz
    reveals gaps, the loop returns to reading the lesson.
    }
    L[Read the lesson] --> P[Do the lab]
    P --> C[Study the case]
    C --> Q[Take the quiz]
    Q -->|gaps?| L
  • Read the lesson and its worked examples and diagrams.
  • Practise in a lab by producing a real project-management artefact.
  • Analyse a case study and answer its discussion questions before revealing the model answers.
  • Check yourself with the quiz and the lab rubric. Answers stay hidden until you try.

Everything you produce feeds the capstone — no work is throwaway. You will use the Templates throughout, and the Glossary when a term needs pinning down.

What you will be able to do at the end

By the time you finish, you should be able to walk into a small software project and:

  • write the charter and know who has to approve it,
  • define and bound the scope, and break it into work packages,
  • build a schedule you can defend, and explain the critical path,
  • produce an estimate with an honest uncertainty range,
  • run the risk, quality, and communication processes,
  • report honestly on progress, and control change rather than absorb it, and
  • close the project with a retrospective a colleague could learn from.

That is the professional baseline the course is built to reach. Experience, judgement under pressure, and accountability for real consequences are earned on real projects — see Skills Progression for an honest account of the levels and their limits.

Your instructor

Engr. Dr. Muhammad Nadeem Majeed — Professor, Department of Data Science (PUCIT), University of the Punjab, Lahore.

The course is written and maintained by the instructor above, and is designed so that you can complete it without an instructor: lessons explain every concept, quizzes hide their answers, and every lab carries its own marking criteria. A short instructor page records the authorship and the published details; teaching notes, assessment guidance, and the module-to-outcome mapping sit in a separate Instructors section, kept apart from the student material so it never intrudes on your learning path.

The repository, licence, and contributing

The course is developed in the open at github.com/nadeem-majeedch/Software-Project-Management.

  • Corrections are welcome. If a lesson is unclear or an answer seems wrong, please say so — see Contributing, or read CONTRIBUTING.md in the repository.
  • Accuracy matters. The course contains no fabricated references, statistics, or citations. Every source listed is real and verifiable; see Standards & Further Reading.
  • Licence status: no licence has been selected yet, so all rights are reserved by the author for the time being. This will be resolved before the course is promoted for reuse; in the meantime you are welcome to read, study, and learn from the material.

  • Contribute a fix

    Typos, unclear explanations, broken links — small contributions are genuinely useful.

    Contributing

  • See how it is built

    Local development, validation, and publishing are documented for maintainers.

    Local Development