- What You Are Actually Studying
- Start With the Pearson Objective Document
- Domain 1: Core Programming Concepts
- Domain 2: Software Development Principles
- Domain 3: Object-Oriented Programming
- Domain 4: Web Applications
- Domain 5: Databases
- Sequencing the Domains Across Your Weeks
- Turning Practice Questions Into Diagnostics
- Fees, Scores and Logistics: What Is and Is Not Established
- Where the Credential Fits Career-Wise
- Frequently Asked Questions
- The Information Technology Specialist - Software Development exam is governed by Pearson and organized into five domains with unweighted objectives.
- Every numbered objective and subtopic is fair game, so skipping "minor" areas like document databases is risky.
- The objective document includes C# and ANSI SQL expectations, so hands-on coding and query practice beats passive reading.
- Fee, item count, duration, passing threshold and pass rate are not established by the objective document; verify them at registration.
What You Are Actually Studying
The Information Technology Specialist - Software Development exam, abbreviated ITS-SD throughout this site, is a Pearson-governed certification that validates foundational software development skills. If you are still orienting yourself, our explainers on what ITS-SD is and what ITS-SD stands for cover the naming and purpose. This guide assumes you have decided to sit the exam and want a practical route to passing it the first time.
The most important fact shaping your preparation is structural: the official Software Development objectives are unweighted. Pearson publishes five domains with numbered objectives and subordinate topics, but it does not tell you that Domain 3 is worth a certain share of the exam and Domain 5 another. That means you cannot rationally "skip" a domain and bet on the rest. A balanced, objective-by-objective approach is the only defensible strategy.
Start With the Pearson Objective Document
Your single most authoritative resource is the Pearson objective document for Software Development. Treat it as a checklist. Every numbered objective (1.1 through 5.5) and every subordinate topic beneath it is in scope. The document also references C# and ANSI SQL expectations and prerequisite technologies. Those are context for how the objectives are framed rather than additional exam domains, but they tell you the flavor of knowledge expected: you should be comfortable reading and reasoning about C#-style code and writing standard SQL.
For a broader walkthrough of how the five areas relate, see our complete guide to all 5 ITS-SD content areas. The sections below go deeper on what to master in each one.
Domain 1: Core Programming Concepts
This domain is the foundation. It covers four objectives, and a weak grasp here will undermine everything that follows.
1.1 Storage, Memory, Data Types and Garbage Collection
Know how values are stored and how memory is reclaimed.
- Distinguish value types from reference types and explain what that means for copying and comparison.
- Understand the stack versus the heap at a conceptual level.
- Explain what garbage collection does, when objects become eligible for collection, and why you do not manually free managed memory.
- Recognize implicit versus explicit conversions and where precision can be lost.
1.2 Algorithms, Flowcharts, Decisions, Loops and Recursion
Be able to read a flowchart and predict program behavior.
- Trace nested loops and conditional branches by hand, including off-by-one boundaries.
- Identify the base case and recursive case in a recursive function and recognize runaway recursion.
- Choose between loop constructs and between if/else chains and switch-style decisions.
1.3 Structured Exception Handling, Testing and Debugging
Expect scenario questions about what happens when code fails.
- Know try/catch/finally flow, including what runs when an exception is thrown or when a return occurs inside a try block.
- Understand catching specific exceptions before general ones and when to rethrow.
- Be familiar with debugging concepts such as breakpoints, stepping and inspecting state, plus the purpose of unit testing.
1.4 Functional Patterns, Events/Delegates/Promises, Asynchrony and Immutability
This is the objective many beginners underestimate.
- Understand delegates and events as the mechanism for callbacks and publish/subscribe behavior.
- Know what a promise represents and how asynchronous code differs from synchronous code in ordering and blocking.
- Explain immutability and why immutable data simplifies reasoning about concurrent code.
- Recognize functional patterns such as passing functions as arguments and avoiding side effects.
Domain 2: Software Development Principles
Domain 2 is the broadest by topic count, spanning process, data structures and security. It rewards breadth of vocabulary, so flashcard-style recall is genuinely useful here.
Process and collaboration (2.1, 2.2, 2.4)
Be able to describe the software development life cycle and compare Agile practices and roles with more linear approaches. Know the major testing types and what each is meant to catch. For 2.2, understand specifications, prototypes and component-based design, and note that the objective explicitly includes generative-AI research, so be prepared to reason about using AI tools as a research aid and about their limitations. For 2.4, know version control fundamentals: commits, branches, merging, conflict resolution and collaborative workflows.
Data structures, searching and sorting (2.3)
Know the characteristics of common data structures (arrays, lists, stacks, queues, dictionaries and similar), when each is the right choice, and how searching and sorting approaches compare on performance. You do not need to derive proofs, but you should recognize why one approach scales better than another.
Security fundamentals (2.5)
This objective bundles cryptography with injection, cross-site request forgery (CSRF) and iframe-related risks. Learn the difference between hashing and encryption, symmetric versus asymmetric approaches, and the purpose of each. Then learn how injection attacks work and how parameterization defends against them, how CSRF tokens work, and why embedding content in iframes creates exposure.
Domain 3: Object-Oriented Programming
Domain 3 is compact but conceptually dense. Questions often present short code snippets and ask what the code does or which principle it demonstrates.
3.1 Classes, Members, Access, Instantiation and Composition
- Differentiate fields, properties, methods and constructors.
- Apply access modifiers correctly and predict what is visible from where.
- Understand instantiation and the difference between static and instance members.
- Explain composition ("has-a") versus inheritance ("is-a") and when to prefer each.
3.2 Inheritance and Generic/Abstract Classes
- Trace constructor and member resolution through an inheritance chain.
- Know what an abstract class can and cannot do, including that it cannot be instantiated directly.
- Understand generics as a way to write type-safe, reusable code without duplicating logic.
3.3 Overriding, Interfaces and Overloading
- Distinguish overriding (runtime, same signature in a derived class) from overloading (compile-time, different parameter lists).
- Understand interfaces as contracts and why a class can implement several.
- Recognize polymorphism in action when a base-type reference calls an overridden member.
A common trap is mixing up overriding and overloading under time pressure. Practice stating the difference in one sentence until it is automatic.
Domain 4: Web Applications
Domain 4 tests how applications are delivered over a network. You do not need to be a full-stack expert, but you do need a coherent mental model of a request traveling from browser to server and back.
Client/server fundamentals (4.1)
Understand HTTP methods and status code families, the roles of HTML, CSS and client-side scripting, what browser developer tools reveal, and how state is maintained over a stateless protocol using mechanisms such as cookies and sessions. Also review the page and application lifecycle: what happens, and in what order, as a page loads and renders.
Hosting, deployment and services (4.2, 4.3)
Know the options for hosting and deploying a web application and the considerations behind each. For web services, understand what a web API is, the common data formats and protocols used to exchange information, and how a RESTful style differs from other approaches. Be able to read a small JSON or XML payload and interpret it.
Architectural patterns (4.4)
Compare MVC, MVVM and single-page application (SPA) approaches. Focus on what each component is responsible for and where data binding or navigation logic lives. Expect questions that describe a scenario and ask which pattern fits.
Domain 5: Databases
Domain 5 combines theory, SQL syntax and data-access tooling. It is highly testable and a good place to earn dependable points if you practice.
5.1 and 5.2: Relational Design and ANSI SQL
- Understand normalization and why it reduces redundancy, plus primary keys, foreign keys and relationship types (one-to-one, one-to-many, many-to-many).
- Write and read SELECT statements with filtering, sorting, grouping, aggregates and joins.
- Know INSERT, UPDATE and DELETE behavior and what stored procedures provide.
5.3: Transactions and Isolation
- Explain the purpose of a transaction and the ACID properties.
- Understand commit versus rollback.
- Recognize how isolation levels trade consistency against concurrency, and the anomalies (such as dirty reads) they prevent.
5.4 and 5.5: Entity Framework, LINQ and Non-Relational Stores
- Understand what an object-relational mapper does, the role of connection pooling, and how LINQ expresses queries in code.
- Know how document databases and key-value stores differ from relational databases and when each is a sensible choice.
Sequencing the Domains Across Your Weeks
This is the one place for generic planning, and it is tied to ITS-SD dependencies. Because concepts build on each other, the order below front-loads foundations. Adjust the length to your timeline and the amount of prior experience you bring.
Domain 1: Core Programming Concepts
- Write small programs that exercise loops, recursion and try/catch/finally.
- Experiment with delegates, events and an asynchronous call so the behavior is not abstract.
Domain 3: Object-Oriented Programming
- Build a small class hierarchy with an abstract base, an interface and overridden members.
- Practice distinguishing overriding from overloading in snippets.
Domain 5: Databases
- Design a normalized schema, then write joins, aggregates and a stored procedure.
- Review transactions, isolation and the document versus key-value distinction.
Domains 4 and 2
- Trace an HTTP request end to end and compare MVC, MVVM and SPA patterns.
- Memorize SDLC, Agile, testing types, version control and security terminology.
Integration and Review
- Take full-length practice sets and map every miss back to a numbered objective.
- Revisit your weakest two objectives before exam day.
Putting Domain 2 late is deliberate: its security and data-structure topics make more sense once you have coded, queried and traced web requests. If you are strong in one area already, compress that week and give the time to your weakest domain.
Turning Practice Questions Into Diagnostics
Practice questions are most valuable as a diagnostic instrument, not a score to chase. After each set, log every miss against its numbered objective (for example, "3.3 overriding versus overloading" or "5.3 isolation levels"). Patterns emerge quickly: you may discover that your errors cluster in asynchrony and events (1.4) or in security attacks (2.5), which is far more actionable than a vague sense of being "bad at web stuff."
Because the exam draws on code reading and SQL, supplement multiple-choice drilling with real execution. Run the C# snippets you are unsure about, write the queries rather than just recognizing them, and set up a throwaway repository to practice branching and merging. You can drill exam-style items on our ITS-SD practice test site, and keep our one-page ITS-SD cheat sheet handy for last-minute review of definitions.
Key Takeaway
Tag every missed question with its objective number. After two or three practice sets, the objectives with the most misses become your remaining study plan, which is the most efficient use of your final week.
Fees, Scores and Logistics: What Is and Is Not Established
Candidates frequently ask about price, length and the passing mark. Here is the honest position based on the Pearson objective document: it defines the skills measured, but it does not establish the current fee, the number of items, the exam duration, the passing threshold, a pass rate or renewal terms. Anything you read elsewhere quoting specific figures should be verified directly with Pearson before you rely on it, since those details can change and are outside the objectives.
| Question | What the objective document establishes | What to do |
|---|---|---|
| Governing body | Pearson | Register through Pearson's official channels |
| Content scope | Five domains, unweighted numbered objectives | Study every objective and subtopic |
| Exam fee | Not established | Confirm at registration |
| Items and duration | Not established | Confirm in the candidate information |
| Passing threshold | Not established | Check the official exam page |
| Renewal terms | Not established | Check the official certification policy |
For deeper dives on these practical questions, see our pages on ITS-SD certification cost, the ITS-SD passing score, and exam dates and scheduling. Because the figures are not fixed by the objectives, plan your preparation around mastery of the content rather than around a target percentage.
Where the Credential Fits Career-Wise
The ITS-SD credential targets people building a foundation in software development: students, career changers and early-career developers. It signals that you have been assessed against a published set of programming, web and database objectives. It is a foundation credential, so it complements a portfolio and project experience rather than replacing them. Employers hiring junior developers, support engineers moving toward development, and apprenticeship programs are the most natural audiences. To weigh the investment, read our analyses of whether the certification is worth it and the roles ITS-SD can open up. If you are wondering whether you meet any prerequisites, our requirements guide explains eligibility.
Frequently Asked Questions
The official Pearson Software Development objectives are unweighted, so no domain is published as worth a larger share. Plan to study all five domains and every numbered objective rather than prioritizing by an assumed percentage.
The objective document includes C# and ANSI SQL expectations and prerequisite technologies as context. You should be able to read code and write standard SQL, so hands-on practice with both is strongly advised.
Start with Core Programming Concepts. Algorithms, exception handling, events and asynchrony underpin the object-oriented, web and database material, so a solid base there makes later domains easier to absorb.
The Pearson objective document does not establish the item count, duration or passing threshold. Confirm those details through Pearson when you register rather than relying on third-party figures.
It is a foundation-level credential, but its breadth across programming, security, web and databases surprises many candidates. See our difficulty guide for a fuller breakdown of where candidates struggle.