- What the ITS-SD Certification Actually Is
- Who Governs It and What That Means for Candidates
- The Five Domains at a Glance
- Domain 1: Core Programming Concepts in Practice
- Domains 2 and 3: Principles and Object-Oriented Design
- Domains 4 and 5: Web Applications and Databases
- The C# and ANSI SQL Context
- What the Objectives Do Not Tell You
- Who Should Pursue It and Who Hires for It
- Sequencing Your Preparation by Domain
- Frequently Asked Questions
- ITS-SD means Information Technology Specialist - Software Development, an entry-level credential built around five objective domains published by Pearson.
- The official objectives are unweighted, so every domain deserves study time rather than a bet on one heavy area.
- The objectives expect C# and ANSI SQL fluency, but these are context, not extra domains.
- Fee, item count, duration, passing threshold and renewal terms are not set by the objective document; confirm them before booking.
What the ITS-SD Certification Actually Is
The Information Technology Specialist - Software Development certification, abbreviated ITS-SD throughout this site, is a credential that validates foundational software development skills. It is not a vendor product badge and it is not a senior-engineer credential. It tests whether a candidate understands how software is designed, written, tested, delivered and connected to data, using a set of published objectives that cover programming fundamentals through databases.
If you want the short definitions first, our pages on what ITS-SD is and what ITS-SD stands for cover the naming, while this article focuses on what the certification contains and who it serves. For the broader picture of the credential itself, see the ITS-SD certification overview.
What distinguishes this exam from many entry-level programming tests is its breadth. A candidate is not only asked to read a loop or identify a data type. The objectives also reach into specifications and prototyping, version control, cryptography and common web attack classes, HTTP and hosting, transaction isolation, and document and key-value databases. In effect, the certification maps the whole working surface of a junior developer rather than a single language feature set.
Who Governs It and What That Means for Candidates
The governing body for this certification is Pearson, and the authoritative source for scope is the published Software Development objective document hosted on the Pearson VUE site. That document is the single most important artifact a candidate can read, because it lists every numbered objective and the subordinate topics beneath each one.
The objective document carries a 2025 copyright, but that date does not establish an exam-version year. Be careful with any third-party claim that tells you which "year" of the exam you are taking; the objectives themselves do not make that statement. Practical logistics such as the current fee, the number of items, the time allowed, the passing threshold, the pass rate and renewal terms are likewise not established by the objective document. Those details are best confirmed at the point of registration. Our dedicated pages on certification cost, passing score and exam dates explain how to approach each of those questions without relying on unverified figures.
The Five Domains at a Glance
The exam content is organized into five domains. Each contains numbered objectives, and each objective contains specific topics a candidate is expected to recognize, apply or reason about.
| Domain | Name | Objective Areas |
|---|---|---|
| 1 | Core Programming Concepts | Memory and data types, algorithms and recursion, exception handling and debugging, functional and asynchronous patterns |
| 2 | Software Development Principles | SDLC and Agile, specifications and prototypes, data structures, version control, cryptography and web risks |
| 3 | Object-Oriented Programming | Classes and composition, inheritance and generics, overriding, interfaces and overloading |
| 4 | Web Applications | Client/server and HTTP, hosting and deployment, web services, MVC/MVVM/SPA patterns |
| 5 | Databases | Relational design, ANSI SQL, transactions, Entity Framework and LINQ, document and key-value stores |
For a section-by-section walkthrough of each area, read our complete guide to all five ITS-SD content areas. The sections below explain what each domain demands in concrete terms.
Domain 1: Core Programming Concepts in Practice
The first domain is where the exam checks whether you understand how code behaves, not just how it looks. It is divided into four objective areas.
1.1 Storage, Memory, Data Types and Garbage Collection
Candidates must understand how values are stored, how data types constrain behavior, and how memory is reclaimed automatically.
- Difference between value and reference semantics and why it affects assignment and comparison
- What garbage collection does and what it does not guarantee
- Choosing appropriate data types for a given piece of information
1.2 Algorithms, Flowcharts, Decisions, Loops and Recursion
Expect to trace logic, read flowcharts and predict output.
- Translating a flowchart into conditional and loop constructs
- Recognizing the base case and recursive case in a recursive routine
- Spotting off-by-one errors and infinite loops
1.3 Structured Exception Handling, Testing and Debugging
This area rewards candidates who have actually debugged real programs.
- Try/catch/finally flow and what executes in which order
- Where exceptions should be caught versus allowed to propagate
- Using tests and debugging techniques to isolate defects
1.4 Functional Patterns, Events, Delegates, Promises, Asynchrony and Immutability
The most conceptually modern slice of Domain 1.
- How events and delegates decouple a publisher from its subscribers
- What a promise represents and how asynchronous work differs from blocking work
- Why immutability reduces certain classes of bugs
Domains 2 and 3: Principles and Object-Oriented Design
Software Development Principles
Domain 2 is the broadest in terms of subject variety. It covers the software development life cycle and Agile roles, the different types of testing, specifications and prototypes, reusable components, and the use of generative AI for research. It then moves into data structures, searching and sorting, and performance, followed by version control and collaboration. It closes with cryptography and security risks, specifically injection, cross-site request forgery and iframe-related exposure.
This domain is deceptively easy to under-prepare for because much of it is conceptual vocabulary rather than code. Candidates who skip it often discover that questions about Agile roles, testing types or branching and merging cannot be answered by programming skill alone. Pay particular attention to how data structure choice affects search and sort performance, and to recognizing what an injection or CSRF attack looks like in a described scenario.
Object-Oriented Programming
Domain 3 is compact but dense. It covers classes, members, access levels, instantiation and composition; inheritance along with generic and abstract classes; and overriding, interfaces and overloading. The classic pitfalls are distinguishing overriding from overloading, knowing when an interface is the right tool versus an abstract class, and understanding when composition is preferable to inheritance. Expect questions that show a short class hierarchy and ask what a call will do.
Domains 4 and 5: Web Applications and Databases
Web Applications
Domain 4 begins with how the client and server interact: HTTP, browser developer tools, state management and the page or request lifecycle. It continues with hosting and deployment, web services along with their data formats and protocols, and finally architectural patterns including MVC, MVVM and single-page applications. The recurring theme is knowing where code runs and how state travels between browser and server.
Databases
Domain 5 is the one most likely to separate candidates who have only written application code from those who have worked with persistent data. It covers relational design including normalization, keys and relationships, then ANSI SQL and stored procedures, followed by transactions and isolation. It also includes Entity Framework, connection pools and LINQ, and ends with document and key-value databases as alternatives to the relational model.
High-Value Database Skills
These topics reward hands-on practice more than memorization.
- Reading a table design and identifying the normalization problem
- Writing and interpreting SELECT statements with joins and filters
- Explaining why isolation levels exist and what anomalies they prevent
- Knowing when a document or key-value store fits better than a relational one
The C# and ANSI SQL Context
The source objectives include C# and ANSI SQL expectations along with prerequisite technologies. It is worth being precise about how to read this. These are context, not additional domains. You will not find a sixth domain titled "C#" or "SQL." Instead, the language and query standard shape how the objectives in the five domains are expressed: delegates, LINQ and Entity Framework point toward a C#-centered environment, while the database objectives anchor to ANSI SQL rather than a vendor-specific dialect.
Practically, this means you should be comfortable reading C# code and standard SQL, even if your daily work uses another language. If you primarily write in a different language, translate the concepts you already know into C# syntax before sitting the exam, since examples are likely to appear in that form.
What the Objectives Do Not Tell You
A good certification guide is honest about its blind spots. The objective document describes what is covered; it deliberately leaves several operational details unspecified. Rather than guess, plan to verify each of the following directly before you commit time or money.
- Fee: not established by the objective document.
- Number of items and duration: not established by the objective document.
- Passing threshold: not established by the objective document.
- Pass rate: not established by the objective document.
- Renewal terms: not established by the objective document.
Because of this, be skeptical of any site that quotes a precise pass percentage or question count as settled fact. Our pages on the pass rate, requirements and eligibility and exam difficulty discuss what can and cannot be stated responsibly.
Key Takeaway
Use the Pearson objective document for scope and confirm fee, timing, scoring and renewal details at registration. Build your study plan around the five domains, not around unverified numbers.
Who Should Pursue It and Who Hires for It
The certification fits learners and early-career professionals who want a structured, vendor-recognized way to show breadth across software development. Typical candidates include students in programming or computer science coursework, career changers moving into development, and junior developers who want to document that their skills extend beyond one framework.
On the employer side, the credential is most relevant to organizations that hire for junior developer, software support, QA-adjacent and application development roles, where a candidate with demonstrated breadth across programming, web and database topics reduces onboarding risk. It is a signal of foundational competence, not a substitute for a portfolio or project experience. We cover the practical employment angle in more detail on our ITS-SD jobs page and discuss compensation questions, without invented figures, in the salary guide. If you are weighing the investment, the ROI analysis walks through the decision.
Sequencing Your Preparation by Domain
Because the objectives are unweighted, a sensible plan gives each domain real attention and orders them by dependency. Foundations first, then the layers that build on them. Here is one ITS-SD-specific way to sequence it.
Domain 1: Core Programming Concepts
- Trace loops, recursion and exception flow by hand
- Practice reading C# snippets even if it is not your main language
Domain 3: Object-Oriented Programming
- Build a small hierarchy using an abstract class and an interface
- Contrast overriding with overloading until the difference is automatic
Domain 2: Software Development Principles
- Review SDLC, Agile roles and testing types
- Practice branching, merging and conflict resolution in version control
- Learn to recognize injection, CSRF and iframe risks from a scenario
Domains 4 and 5: Web Applications and Databases
- Inspect HTTP requests in browser tools and map them to lifecycle concepts
- Write SQL against a normalized schema and reason about transactions
Domain 3 comes before Domain 2 here because object-oriented fluency strengthens the later web and data-access material, while Domain 2 is easier to absorb once you have written enough code to appreciate testing, version control and security. After the first pass, spend remaining time on weak spots rather than re-reading comfortable material. For a fuller plan, see the ITS-SD study guide and the condensed cheat sheet, and when you are ready to test yourself under realistic conditions, use the ITS-SD practice tests to find which domains still need work. For structured instruction beyond self-study, our training overview outlines the options.
Frequently Asked Questions
In this context, ITS-SD stands for Information Technology Specialist - Software Development. It is a certification built around five published objective domains covering programming, development principles, object-oriented design, web applications and databases.
The governing body is Pearson. The scope of the exam is described in the Software Development objective document published on the Pearson VUE site, which lists every numbered objective and subordinate topic.
The official Software Development objectives are unweighted, so the objective document does not assign percentages to the domains. Plan to study all five rather than concentrating on one.
The objectives include C# and ANSI SQL expectations and prerequisite technologies. These are context for the five domains rather than extra domains, so you should be able to read C# code and standard SQL comfortably.
The objective document does not establish the current fee, item count, duration, passing threshold, pass rate or renewal terms. Confirm these at registration rather than relying on third-party figures. Our pages on cost and passing score explain how to verify them.
Understanding what the ITS-SD certification covers is the first step toward preparing for it efficiently. Start with the Pearson objectives, map them to the five domains above, and use the linked guides on this site to go deeper where you need it. If you are still deciding between related searches, our pages on what ITS-SD certification is and the meaning of ITS-SD provide additional context.