- What This Cheat Sheet Covers (and What It Doesn't)
- Exam Facts You Can Rely On
- Domain 1: Core Programming Concepts
- Domain 2: Software Development Principles
- Domain 3: Object-Oriented Programming
- Domain 4: Web Applications
- Domain 5: Databases
- Confusable Pairs That Cost Points
- Sequencing Your Review by Domain
- Frequently Asked Questions
- The Pearson-published ITS-SD objectives cover five domains, and the official objective document does not weight them.
- C# and ANSI SQL expectations appear in the objectives as context, not as extra domains.
- Fee, item count, duration, passing threshold and renewal terms are not in the objective document, so confirm them with Pearson.
- Domain 2 mixes SDLC, data structures, version control and security, so expect breadth over depth there.
What This Cheat Sheet Covers (and What It Doesn't)
This page is a compressed review of the Information Technology Specialist - Software Development (ITS-SD) objectives published by Pearson. It follows the five official domains and their numbered subtopics, then adds the distinctions and mental shortcuts that tend to separate a confident answer from a guess. If you want the long-form treatment of each area, pair this sheet with our complete guide to all 5 ITS-SD content areas. If you are still building a plan, start with the ITS-SD study guide.
One honesty note before the facts: the official objective document is a scope statement, not a rulebook for exam logistics. That shapes what a trustworthy cheat sheet can and cannot say, and we have deliberately avoided padding it with numbers that nobody has verified.
Exam Facts You Can Rely On
Here is what the published objective document establishes, and what it leaves open. Treat the right-hand column as a to-do list to resolve directly with Pearson before you schedule.
| Item | Status in the official objective document |
|---|---|
| Governing body | Pearson |
| Subject | Software Development, organized into five domains |
| Domain weighting | Objectives are unweighted |
| Languages and query standards referenced | C# and ANSI SQL expectations, plus prerequisite technologies, are cited as context |
| Exam-version year | Not established; the 2025 copyright does not identify a version year |
| Fee, item count, duration | Not established by the objective document |
| Passing threshold, pass rate, renewal terms | Not established by the objective document |
Domain 1: Core Programming Concepts
This domain is the language-agnostic foundation. Expect questions that show a short code or pseudocode fragment and ask what happens, which mechanism applies, or where a defect lives.
1.1 Storage, memory, data types and garbage collection
Know how values are stored and why type choice matters.
- Value types versus reference types, and what copying each one really copies
- The stack-versus-heap intuition: short-lived value storage versus managed object storage
- What garbage collection reclaims (unreachable objects) and why it removes the need for manual freeing
- Implicit versus explicit conversion, and where precision or range can be lost
1.2 Algorithms, flowcharts, decisions, loops and recursion
Be able to read a flowchart and trace logic by hand.
- Flowchart symbols: start/end, process, decision, input/output
- Selection structures (if/else, switch) and the loop family (for, while, do-while, foreach)
- The difference between a loop that may run zero times and one that always runs at least once
- Recursion needs a base case and progress toward it; missing either causes runaway calls
1.3 Structured exception handling, testing and debugging
Know the shape of try/catch/finally and the role of each block.
- Catch specific exceptions before general ones
finallyruns whether or not an exception occurred, which makes it the place for cleanup- Syntax errors, runtime errors and logic errors behave differently and surface at different times
- Breakpoints, stepping and watching variables are the core debugging moves
1.4 Functional patterns, events/delegates/promises, asynchrony and immutability
This subtopic trips up candidates who learned only procedural code.
- Delegates reference methods; events let a publisher notify subscribers
- Promises represent a future result and avoid deeply nested callbacks
- Asynchronous code lets work proceed without blocking the caller
- Immutable data cannot change after creation, which reduces side effects and simplifies reasoning about shared state
Domain 2: Software Development Principles
Domain 2 is the broadest, stitching together process, design, performance, collaboration and security. Questions are often scenario-based: "Which approach fits this situation?"
2.1 and 2.2: Process, specifications and research
- SDLC: know the phases from requirements through maintenance and the order in which they typically occur.
- Agile: recognize the roles, iteration-based delivery, and the preference for working software and feedback over exhaustive upfront documentation.
- Testing types: unit, integration, system and acceptance testing each have a distinct scope; match the type to the scenario.
- Specifications, prototypes and components: a prototype validates an idea early; a component is a reusable, replaceable unit.
- Generative-AI research: understand AI tools as aids for finding and drafting information that still require human verification.
2.3: Data structures, searching, sorting and performance
- Arrays and lists favor indexed access; stacks are last-in-first-out; queues are first-in-first-out
- Dictionaries and hash-based structures favor fast lookup by key
- Binary search requires sorted data; linear search does not
- Know the qualitative idea of efficiency growth: constant, linear and worse-than-linear behavior as data grows
2.4 and 2.5: Version control and security
- Commit, branch, merge, pull and conflict resolution are the everyday collaboration vocabulary
- Hashing is one-way and suited to integrity and password storage; encryption is reversible with a key
- Symmetric encryption uses one shared key; asymmetric uses a public/private pair
- SQL injection is stopped by parameterized queries, not by trusting input
- CSRF abuses a user's authenticated session; iframe risks involve embedding or being embedded by untrusted content
Key Takeaway
For the security items in 2.5, memorize the defense paired with each attack: parameterized queries for injection, anti-forgery tokens for CSRF, and framing restrictions for iframe abuse. Questions usually ask for the mitigation, not just the definition.
Domain 3: Object-Oriented Programming
The three subtopics are compact but vocabulary-dense. This domain rewards exact terminology, and wrong answers are usually near-synonyms.
3.1 Classes, members, access, instantiation and composition
- A class is a blueprint; an object is an instance created from it
- Members include fields, properties, methods and constructors
- Access modifiers (public, private, protected, internal) control visibility
- Composition means "has-a" (an object contains another); inheritance means "is-a"
3.2 Inheritance and generic/abstract classes
- A derived class inherits members from a base class and can extend them
- An abstract class cannot be instantiated and may contain unimplemented members that derived classes must supply
- Generics let one class or method work across types while preserving type safety
3.3 Overriding, interfaces and overloading
- Overriding replaces a base-class behavior in a derived class (same signature)
- Overloading provides several methods with the same name but different parameter lists
- An interface defines a contract with no implementation of its own; a class can implement many interfaces
Domain 4: Web Applications
Domain 4 treats the web as a system: browser, network, server, hosting, services and architecture. Think in terms of "who does what, and where does the data live."
4.1: Client/server technologies, HTTP, browser tools, state and lifecycle
- HTML structures content, CSS styles it, and JavaScript adds behavior on the client
- HTTP is stateless; sessions, cookies and other mechanisms reintroduce state
- Common methods map to intent: GET retrieves, POST creates or submits, PUT replaces or updates, DELETE removes
- Status code families: 2xx success, 3xx redirection, 4xx client error, 5xx server error
- Browser developer tools let you inspect requests, the DOM, console output and timing
4.2 and 4.3: Hosting, deployment and web services
- Know the difference between development, staging and production environments
- Web services expose functionality over the network using standard protocols and data formats
- JSON and XML are the data formats to compare: JSON is lighter and common in modern APIs; XML is more verbose and self-describing
- REST-style services use HTTP methods and resource URLs; SOAP-style services use a formal XML envelope
4.4: MVC, MVVM and SPA patterns
| Pattern | Core idea | Memory hook |
|---|---|---|
| MVC | Controller handles input, updates the model, selects the view | Controller is the traffic director |
| MVVM | View binds to a view model that exposes data and commands | Data binding does the wiring |
| SPA | One page loads once; client-side code updates content dynamically | Navigation without full page reloads |
Domain 5: Databases
The databases domain pairs design theory with practical querying and data-access technique. The objectives reference ANSI SQL specifically, so favor standard SQL over vendor-specific shortcuts when you practice.
5.1 Relational design, normalization, keys and relationships
- A primary key uniquely identifies a row; a foreign key references a primary key elsewhere
- One-to-one, one-to-many and many-to-many relationships; many-to-many needs a junction table
- Normalization reduces redundancy and update anomalies by splitting data into related tables
5.2 ANSI SQL and stored procedures
- SELECT, INSERT, UPDATE and DELETE are the core data operations
- WHERE filters rows before grouping; HAVING filters groups after aggregation
- JOIN types: INNER returns matches only; LEFT keeps all left-table rows; know what appears as NULL
- Stored procedures are precompiled, reusable server-side routines that accept parameters and help centralize logic
5.3 Transactions and isolation
- ACID: atomicity, consistency, isolation, durability
- COMMIT makes changes permanent; ROLLBACK undoes them
- Isolation levels trade concurrency for protection against anomalies such as dirty reads
5.4 and 5.5: Entity Framework, pools, LINQ, document and key-value stores
- Entity Framework is an object-relational mapper that lets code work with entities instead of hand-written SQL
- Connection pooling reuses open connections to cut the cost of repeatedly opening new ones
- LINQ expresses queries directly in code against collections or data sources
- Document databases store flexible, self-contained documents; key-value stores map a unique key to a value for very fast lookups
- Know when relational structure is preferable and when schema flexibility is the better fit
Confusable Pairs That Cost Points
Most missed questions on an exam like this come from near-miss vocabulary. Rehearse these pairs until the distinction is automatic.
| Pair | The distinction |
|---|---|
| Overriding vs. overloading | Overriding changes inherited behavior; overloading reuses a name with different parameters |
| Abstract class vs. interface | An abstract class can carry shared implementation; an interface is a pure contract |
| Value type vs. reference type | Copying a value type copies the data; copying a reference type copies the pointer |
| Hashing vs. encryption | Hashing is one-way; encryption is reversible with the right key |
| WHERE vs. HAVING | WHERE filters rows; HAVING filters aggregated groups |
| Inner vs. left join | Inner keeps matches only; left keeps every left-table row |
| Composition vs. inheritance | "Has-a" versus "is-a" |
| Stack vs. queue | Last-in-first-out versus first-in-first-out |
| Commit vs. rollback | Make permanent versus undo |
Sequencing Your Review by Domain
The only scheduling advice worth giving is the one tied to how these domains depend on each other. Domain 1 vocabulary (types, memory, exceptions, async) underpins nearly everything else, and Domain 3 builds directly on it. Domain 5 is the most self-contained and the easiest to practice hands-on with a real database.
Foundations first
- Domain 1: trace loops, recursion and try/catch/finally by hand
- Write small C# snippets covering value versus reference behavior
Structure and design
- Domain 3: build a small class hierarchy using an interface, an abstract class and an override
- Domain 2.3: compare searching and sorting approaches on paper
Web and data
- Domain 4: inspect real HTTP requests in browser tools and map patterns to MVC, MVVM and SPA
- Domain 5: write joins, grouped queries and a transaction against a practice database
Breadth and weak spots
- Domain 2: SDLC, Agile, testing types, version control and security pairings
- Full practice sets, then revisit whichever domain scored lowest
Adjust the pace to your background. If you already write C# professionally, compress Weeks 1 and 2; if you are newer to SQL, extend Domain 5. Our difficulty guide discusses which topics candidates tend to find hardest, and our requirements article covers eligibility questions. When you are ready to test yourself under realistic conditions, the ITS-SD practice tests are the quickest way to find gaps.
Frequently Asked Questions
The official objective document does not publish domain weights, so the objectives are unweighted. Prepare all five domains rather than assuming any one is minor, and use practice results to guide extra study time.
The objective document includes C# and ANSI SQL expectations along with prerequisite technologies. They are context for how topics are examined, not additional domains. Practicing real code and standard SQL is the most reliable way to prepare.
The objective document does not establish the passing threshold, item count or duration. Confirm current details directly with Pearson when you register, and see our passing score article for what is and is not confirmed.
Start with Core Programming Concepts, since types, memory, exceptions and asynchrony underpin the object-oriented, web and database material. Then move to Object-Oriented Programming before tackling the broader Domain 2 survey.
It can help early-career candidates document foundational skills across programming, web and data topics. For a fuller discussion, read our ROI analysis and the overview of ITS-SD jobs.