Security Engineering for Software Teams

Security as an engineering discipline. Threat modeling, the cryptography you will actually use, identity and authorization models, the vulnerability classes that keep shipping, secrets and cloud least privilege, supply chain integrity, detection, and incident response.
Level: Intermediate
Study Time: 14h
Lessons: 26
Quizzes: 442
Course Overview

Security is usually taught to software engineers in one of two ways, and both fail. The first is a checklist: use parameterised queries, hash passwords, enable multi factor authentication, rotate keys. The checklist is correct and it does not transfer, because the next system you build will have a failure the checklist did not name. The second is offensive: here is how an attacker breaks a web application. That is entertaining and mostly useless to the person who has to ship the application, because knowing one way in does not tell you how to design a system that has no ways in that matter. This course teaches security the way the rest of engineering is taught, as a discipline with models, quantities and trade offs, aimed at the people who build and operate systems.

It opens with thinking rather than tools. Threat modeling is taught as a structured conversation about what you are building, what can go wrong, what you will do about it and whether you did a good job, with data flow diagrams, trust boundaries and a method for enumerating threats that does not depend on the imagination of whoever is in the room. Attack surface is treated as something you can measure and shrink. Risk and severity get a lesson of their own, because a security programme that treats every finding as critical treats none of them as critical, and triage is the skill that decides what gets fixed this week.

The cryptography section covers the cryptography you will actually use and the mistakes people actually make with it. Password storage with memory hard functions and the parameters that matter. Symmetric encryption with authenticated modes, and why nonce reuse in an otherwise perfect cipher can be catastrophic. Signatures, public keys and certificate chains as a system of delegated trust. Key management and envelope encryption, which is where most real encryption failures happen, because the cipher was fine and the key was in the repository. None of it asks you to implement a primitive. All of it asks you to choose and compose them correctly.

Identity covers sessions and tokens, including the specific ways JSON Web Tokens are misused, OAuth 2 and OpenID Connect flows with the reasons each parameter exists, and authorization models from role based through attribute based to relationship based access control. The vulnerability section then covers the classes that keep shipping year after year: injection, cross site scripting and request forgery explained through the browser's security model, server side request forgery, unsafe deserialization and file upload, and broken access control, which is now the most common serious finding in web applications because it cannot be fixed by a library. Each is taught from the defender's side: why the class exists, what the structural fix is, and how to test for it.

Infrastructure and cloud covers secrets management, network segmentation and the zero trust model as an engineering position rather than a product, and cloud misconfiguration with least privilege as something you can measure. The supply chain section covers dependencies and software bills of materials, build pipeline integrity with provenance and signing, and container image security. Detection and response covers logging for security as a different problem from logging for debugging, detection rules with the precision and recall arithmetic that decides whether the team trusts them, and incident response with forensics that preserve evidence.

The final section is about practice. A secure development lifecycle that engineers will follow, security code review that finds the bugs tools miss, authorized testing and bug bounty programmes with scope and safe harbour written down, and the compliance and privacy obligations that shape what you are allowed to collect and how long you may keep it. Throughout, the attacker's view appears only as far as a defender needs it in order to build and test correctly, and every testing activity described assumes written authorization.

By the end you will be able to run a threat model for a feature, choose and parameterise the cryptography it needs, design its authorization, recognise the vulnerability classes in review, keep its secrets out of places they should not be, prove what went into its build, and detect and respond when something goes wrong anyway.

Security Engineering for Software Teams
Enroll Now

Get instant access to all current and upcoming courses by subscribing.