ITS-SD logo
Focused certification exam prep
Start practice

What Is ITS-SD?

TL;DR
  • ITS-SD stands for Information Technology Specialist - Software Development, an exam published through Pearson.
  • The official objectives cover five domains: core programming, development principles, OOP, web applications and databases.
  • The objectives are unweighted, so no domain is officially declared more valuable than another.
  • C# and ANSI SQL expectations appear in the objectives as context, not as extra domains.

What the ITS-SD Credential Actually Is

ITS-SD is the short name for Information Technology Specialist - Software Development, a certification exam that measures whether a candidate understands the foundational concepts behind building software. It is not a vendor product exam about a single framework, and it is not a deep specialty credential for senior engineers. It sits at the point where a learner moves from "I can follow a tutorial" to "I understand why code is structured the way it is."

The exam spans a deliberately wide surface: how programs store data in memory, how algorithms make decisions, how object-oriented designs are modeled, how web applications communicate over HTTP, and how relational and non-relational databases keep data consistent. That breadth is the defining characteristic of the credential. A candidate who is strong in one area but has never touched the others will feel the gaps quickly.

If you are searching for a plain-language definition, our related explainers cover the same ground from different angles: What Does ITS-SD Stand For? addresses the name itself, while ITS-SD Certification frames it as a credential. This article focuses on what is actually inside the exam.

Who Governs It and What the Objectives Document Tells You

The governing body for this credential is Pearson. The authoritative description of what the exam covers is the published Software Development objective document hosted on the Pearson VUE site. That document is the single most reliable source a candidate has, because it lists every numbered objective and the subordinate topics beneath each one.

Several characteristics of that document shape how you should prepare:

  • The objectives are unweighted. Unlike many certifications that publish percentage ranges per domain, this document does not assign relative weights. You should not assume that one domain will dominate the exam, nor that any domain can be safely skipped.
  • The 2025 copyright is not an exam-version year. The date printed on the document tells you when the document carries its copyright, not that a specific "2025 exam version" exists. Treat the numbered objectives themselves as the scope, rather than inferring a version label.
  • Every published numbered objective is in scope. The subordinate topics under each objective are part of the expectation, so reading only the headline of an objective is not enough.
Read the source document first: Before buying any study material, read the full objective document line by line. Every other resource, including this site, is an interpretation of it. When a practice question tests something that is not traceable to a numbered objective, treat it with suspicion.

The Five Content Domains at a Glance

The objectives organize the exam into five domains. The table below summarizes them using the exact domain names from the objectives. For a deeper walkthrough of each one, see our complete guide to all 5 ITS-SD content areas.

DomainNameSubtopic Areas
1Core Programming ConceptsStorage and memory, algorithms and flowcharts, exception handling and debugging, functional patterns and asynchrony
2Software Development PrinciplesSDLC and Agile, specifications and prototypes, data structures and performance, version control, cryptography and web security risks
3Object-Oriented ProgrammingClasses and composition, inheritance and generics, overriding and interfaces
4Web ApplicationsClient/server and HTTP, hosting and deployment, web services, MVC/MVVM/SPA patterns
5DatabasesRelational design, ANSI SQL and stored procedures, transactions, Entity Framework and LINQ, document and key-value stores

Domain 1: Core Programming Concepts in Detail

Domain 1 is where the exam establishes whether you understand programs at the level of the machine and the logic. It is easy to underestimate because the topics sound basic, but the objectives go beyond "what is a variable."

1.1 Storage, Memory, Data Types and Garbage Collection

You need to explain how values are stored, how data types constrain what can be done with a value, and how memory is reclaimed automatically in managed environments.

  • Distinguish value storage from reference storage and recognize what that means for copying and comparison
  • Understand what garbage collection does conceptually and why it matters for resource handling
  • Match data types to the kind of data they represent

1.2 Algorithms, Flowcharts, Decisions, Loops and Recursion

Expect to read and reason about logic expressed as flowcharts and as code, including how decisions branch and how repetition terminates.

  • Trace a loop by hand and predict its output
  • Recognize the base case and recursive case in a recursive routine
  • Translate between a flowchart and equivalent control flow

1.3 Structured Exception Handling, Testing and Debugging

This objective rewards candidates who have actually debugged real code, not only written it.

  • Understand try, catch and finally flow and what executes in each path
  • Know why unit-level testing and debugging techniques exist and when each applies

1.4 Functional Patterns, Events/Delegates/Promises, Asynchrony and Immutability

This is the most conceptually modern part of Domain 1. It asks you to reason about code that does not run top to bottom in a single thread of obvious control.

  • Describe how events and delegates decouple a signal from its handler
  • Explain what a promise represents and why asynchronous operations are used
  • Understand immutability and the reasoning for avoiding shared mutable state

Domains 2 and 3: Development Principles and Object-Oriented Programming

Software Development Principles

Domain 2 is the most varied domain in the exam, mixing process knowledge with technical fundamentals. Candidates who come from a purely hands-on coding background are often surprised by how much of it concerns process and risk rather than syntax.

  • SDLC, Agile roles and testing types (2.1): know the stages of the software development life cycle, the roles that appear in Agile teams, and the different kinds of testing and what each is meant to catch.
  • Specifications, prototypes, components and generative-AI research (2.2): understand how requirements become specifications, why prototypes are built, how reusable components fit in, and how generative AI can be used as a research aid.
  • Data structures, searching/sorting and performance (2.3): choose an appropriate structure for a problem and reason about how searching and sorting choices affect performance.
  • Version control and collaboration (2.4): understand how teams track changes, branch, merge and resolve conflicts.
  • Cryptography and injection/CSRF/iframe risks (2.5): recognize the core ideas of cryptography and identify common web attack categories, including injection, cross-site request forgery and iframe-related risks.

Object-Oriented Programming

Domain 3 is compact but unforgiving, because object-oriented vocabulary is tested precisely. The difference between overriding and overloading, or between an interface and an abstract class, is exactly the kind of distinction exam items probe.

Domain 3 Topic Map

The three objective groups build on each other, so learn them in order.

  • 3.1: classes, members, access modifiers, instantiation and composition
  • 3.2: inheritance, plus generic and abstract classes
  • 3.3: overriding, interfaces and overloading
Composition versus inheritance: The objectives list composition alongside inheritance on purpose. Be ready to explain when "has a" relationships are a better model than "is a" relationships, not just to define each term.

Domains 4 and 5: Web Applications and Databases

Web Applications

Domain 4 tests how software behaves when it is split across a client and a server. The emphasis is on understanding the moving parts rather than building a full site.

  • Client/server web technologies, HTTP, browser tools, state and lifecycle (4.1): understand how requests and responses work, what browser developer tools reveal, and how state is maintained over a stateless protocol.
  • Hosting and deployment (4.2): know the options for making an application available and the considerations around deploying it.
  • Web services and formats/protocols (4.3): understand how applications expose and consume services and which data formats and protocols are involved.
  • MVC/MVVM/SPA patterns (4.4): distinguish the architectural patterns and recognize which one a described application uses.

Databases

Domain 5 is where the exam moves from code to data. It deliberately covers both relational and non-relational thinking, which means you cannot rely on SQL alone.

Domain 5 Priorities

The five objective groups span design, querying, integrity, object mapping and alternative stores.

  • 5.1: relational design, normalization, keys and relationships
  • 5.2: ANSI SQL and stored procedures
  • 5.3: transactions and isolation
  • 5.4: Entity Framework, connection pools and LINQ
  • 5.5: document and key-value databases

Transactions and isolation (5.3) deserve extra attention. They require you to reason about what happens when concurrent operations touch the same data, which is conceptual work that cannot be memorized as a list of definitions.

C#, ANSI SQL and the Prerequisite Technologies

The source objectives include expectations around C# and ANSI SQL, along with prerequisite technologies. The important point is how to interpret that. These are context for the five domains, not additional domains. In practice, it means code samples and query examples in the exam are likely to be written in these technologies, so you should be comfortable reading them even when the underlying question is conceptual.

Entity Framework and LINQ in Domain 5 are a natural illustration. They are .NET-oriented data access tools, so familiarity with the C# ecosystem makes those objectives far easier to absorb. A candidate who has only ever written code in another language can still pass, but should expect to spend extra time learning to read C# comfortably.

Key Takeaway

Do not treat C# and SQL as separate subjects to master in isolation. Learn them as the vehicles through which the five domains are expressed, and practice reading short snippets quickly.

What the Objectives Do Not Tell You

An honest overview of ITS-SD has to name what is not established by the objective document. It does not state the current exam fee, the number of items, the duration, the passing threshold, any pass rate or the renewal terms. Anyone who quotes a precise figure for these without pointing to the current official booking and policy pages is guessing.

That matters for planning, so verify the following directly at the point of registration rather than relying on third-party summaries:

  1. The current fee for your region and any retake pricing
  2. The scheduled length of the exam and the number of questions
  3. The scoring and passing threshold
  4. Whether the credential carries any renewal expectation

We keep dedicated pages for each of these topics so you can see how they are framed once official figures are confirmed: ITS-SD certification cost, ITS-SD passing score, ITS-SD pass rate and ITS-SD exam dates.

Who Should Pursue It and Where It Fits Professionally

ITS-SD suits people who want a structured, objective-driven way to demonstrate foundational software development knowledge. Typical candidates include students in programming or computing pathways, career changers moving into development, and early-career developers who learned by doing and want to validate the theory underneath their practice.

Because the credential tests breadth rather than depth in any single framework, it works best as a signal of well-rounded fundamentals. It can support applications for entry-level and junior development roles, internships and apprenticeship-style positions, and it can give hiring managers a common reference point for what a candidate has studied. It is not a substitute for a portfolio or for hands-on project experience, and employers vary in how much weight they give any entry-level credential.

If you are weighing the professional return, our ROI analysis, salary guide and jobs overview go into the career side. For eligibility questions, see ITS-SD requirements.

Pair the credential with proof of work: A small project that touches a web front end, an API and a database exercises Domains 3, 4 and 5 at once, and gives you something concrete to discuss in an interview alongside the certification.

Sequencing Your Preparation Around the Domains

Because the objectives are unweighted, a sensible plan gives every domain real attention and orders them by dependency. Concepts in Domain 1 underpin everything else, object-oriented ideas feed the web and data layers, and databases are easiest once you can already think in terms of classes and services. The timeline below is one reasonable ordering, and you can stretch it as your schedule demands. For a fuller method, see the ITS-SD study guide and the one-page cheat sheet.

Week 1

Core Programming Concepts

  • Memory, data types and garbage collection
  • Trace loops, decisions and recursion by hand
  • Practice exception flow and asynchrony
Week 2

Software Development Principles

  • SDLC, Agile roles and testing types
  • Data structures, searching and sorting trade-offs
  • Version control workflow and web security risks
Week 3

Object-Oriented Programming

  • Classes, access and composition
  • Inheritance, abstract and generic classes
  • Overriding, overloading and interfaces
Week 4

Web Applications

  • HTTP, state and lifecycle
  • Hosting, deployment and web services
  • MVC, MVVM and SPA distinctions
Week 5

Databases and Review

  • Normalization, ANSI SQL and transactions
  • Entity Framework, LINQ and document/key-value stores
  • Timed practice across all five domains

Once you have covered each domain, move to realistic practice. Working through questions in the style of the exam shows you which objectives you only recognize versus genuinely understand. Our ITS-SD practice tests are built around the same five domains, and if you are unsure how demanding the exam feels, read how hard the ITS-SD exam is before you commit to a date.

Frequently Asked Questions

What does ITS-SD stand for?

ITS-SD stands for Information Technology Specialist - Software Development. It is an exam published through Pearson that measures foundational software development knowledge across five domains. See also What Does ITS-SD Mean? for more on the terminology.

How many domains does the ITS-SD exam cover?

The official objectives are organized into five domains: Core Programming Concepts, Software Development Principles, Object-Oriented Programming, Web Applications and Databases. The objectives are unweighted, so none is officially declared more important than another.

Do I need to know C# and SQL?

The source objectives include C# and ANSI SQL expectations as context rather than as separate domains. You should be able to read C# and SQL examples, especially for topics such as Entity Framework, LINQ and stored procedures.

What is the exam fee, length and passing score?

The objective document does not establish the current fee, item count, duration or passing threshold. Confirm each of these on the official Pearson registration pages before booking rather than relying on unofficial figures.

Is the ITS-SD a good starting credential for a development career?

It is well suited to learners and early-career developers who want to validate fundamentals across programming, OOP, web and data topics. It works best alongside project experience, since employers also look for evidence that you can build working software.

Ready to pass your ITS-SD exam?

Put this into practice with free ITS-SD questions across every exam domain.