CPA ISC Area I.A — Building, Running, and Controlling Information Systems
I.A.1 IT infrastructure
What IT infrastructure is
IT infrastructure is the collection of technology resources—hardware, software, networks, data platforms, and supporting services—that enables an organization’s information systems to operate. If you think of an information system as “a business process that uses technology,” then infrastructure is the underlying environment that makes that process possible: the computers and servers that run applications, the network that connects users to those applications, and the storage/database layers where information lives.
In CPA ISC, you care about infrastructure because it shapes:
- Risks (for example, a single server with no redundancy is a single point of failure).
- Controls (for example, who can administer servers or change firewall rules?).
- Reliability of financial reporting (accounting systems run on infrastructure—if it’s misconfigured or unavailable, transactions may be incomplete, inaccurate, or delayed).
Core infrastructure components (and how they work together)
Infrastructure is easiest to understand as layers that depend on each other:
End-user computing (EUC): laptops, desktops, mobile devices, thin clients.
- These are where users initiate work—entering invoices, approving payments, running reports.
- Key control idea: EUC can become a “shadow system” risk if critical spreadsheets or local databases are used without governance.
Servers and compute: physical servers, virtual machines, containers, and cloud compute.
- A server is a system that provides services (applications, databases, authentication) to other systems.
- Virtualization lets multiple virtual machines (VMs) run on one physical host using a hypervisor. This improves utilization and can make provisioning faster.
- Containers (e.g., Docker) package an application and its dependencies in a lightweight way; they share an operating system kernel and are often orchestrated (e.g., Kubernetes).
- Control angle: virtualization and containers introduce new admin layers (hypervisor, orchestration) that must be secured and logged.
Operating systems and middleware: Windows/Linux, web servers, application servers, message queues, integration tools.
- Middleware helps applications communicate reliably (for example, passing transactions from an e-commerce platform to an ERP).
- Integration failures here can create data completeness issues—orders placed but never posted to accounting.
Networks: switches, routers, firewalls, VPNs, wireless access points, DNS.
- The network controls how data flows and who can talk to what.
- A classic control concept is network segmentation—separating environments (user networks vs. server networks; production vs. development) to reduce the blast radius of an attack or misconfiguration.
Storage and data platforms: file servers, storage arrays, cloud storage, databases, data warehouses.
- Storage is where files and backups live; databases are structured systems for transactions.
- Control angle: access rights, encryption, backup/restore capability, and logging are critical.
Identity and access services: directories (e.g., Active Directory), single sign-on, multi-factor authentication.
- These services determine who a user is and what they can access.
- Infrastructure risk often comes from excessive privileges (for example, too many users with local admin rights or broad database access).
Facilities and environmental controls: data centers, power, HVAC, physical security.
- Physical failures (power loss, overheating) can cause system outages and data loss.
On-premises vs. cloud: why the distinction matters for controls
A common misconception is that “moving to the cloud means the provider handles security and controls.” In reality, cloud usually follows a shared responsibility model: the provider secures parts of the underlying infrastructure, while the customer remains responsible for configuration, access management, data governance, and application-level controls.
- On-premises: the organization manages (and controls) facilities, hardware, and most platform layers.
- Cloud (IaaS/PaaS/SaaS):
- IaaS: you manage OS, applications, and configuration; the provider manages physical infrastructure.
- PaaS: the provider also manages OS/runtime; you manage application configuration and data.
- SaaS: the provider runs the application; you still manage user access, configurations, and how the SaaS output is used in business processes.
From an ISC perspective, what changes is the evidence and control focus:
- You may rely on SOC reports (e.g., SOC 1 for controls relevant to financial reporting) for service organizations.
- You still need strong internal controls over provisioning users, configuring security settings, and monitoring.
Example: infrastructure choices affecting accounting outcomes
Imagine Accounts Payable uses an ERP hosted on a single on-prem server.
- If that server fails, invoices can’t be entered or approved—leading to late payments and potential cutoff issues.
- If server administrators have unrestricted access and logging is weak, they might alter system configurations or even data pathways without detection.
A better-controlled design might include:
- Redundant servers (or cloud high availability),
- Centralized identity management with least privilege,
- Logged and reviewed administrative actions,
- Segmented networks between user devices and database servers.
Exam Focus
- Typical question patterns:
- Identify which infrastructure component is implicated in a scenario (network vs. database vs. identity service) and the likely control implications.
- Compare on-prem vs. cloud responsibilities and what evidence an auditor/CPA would look for (e.g., SOC reports plus internal controls).
- Spot “single points of failure” and recommend infrastructure-level mitigations (redundancy, segmentation, access restrictions).
- Common mistakes:
- Treating “the cloud” as fully outsourced control responsibility—ignoring customer configuration and access governance.
- Mixing up application controls (within the ERP) with infrastructure/IT general controls (admin access, change control, backups).
- Overlooking that virtualization/container layers add privileged roles that must be controlled and logged.
I.A.2 Enterprise and accounting information systems
What enterprise and accounting information systems are
An enterprise information system is an integrated system used across the organization to support core operations—sales, procurement, inventory, HR, finance, and reporting. The most common example is an ERP (Enterprise Resource Planning) system, which aims to use a shared database and standardized processes across functions.
An accounting information system (AIS) is the set of processes, people, data, and technology used to:
- Capture and validate transactions,
- Process and store them,
- Produce outputs such as journal entries, subledger reports, financial statements, and management reporting.
In practice, AIS may be a module inside an ERP (general ledger, AP, AR, fixed assets) plus connected systems (payroll vendor, billing platform, bank interfaces).
Why it matters (especially for controls and financial reporting)
Accounting is a “data pipeline” from real-world economic events to financial statements. If the system design is poor or controls are weak, you get predictable failure modes:
- Transactions are not recorded (completeness problem),
- Recorded incorrectly (accuracy/valuation problem),
- Recorded in the wrong period (cutoff problem),
- Recorded without proper authorization (occurrence/validity problem).
Enterprise systems also raise governance questions:
- Who can create vendors?
- Who can change payment terms?
- Who can post journal entries directly to the general ledger?
These are not just “IT questions”—they are control questions tied to fraud and error risk.
How these systems work: input → processing → output (with integration)
A useful mental model is Input–Processing–Output (IPO) with feedback/monitoring.
Inputs: source documents and electronic feeds
- Examples: purchase orders, receiving reports, vendor invoices, customer orders, time sheets.
- Risks: duplicate invoices, invalid vendors, incorrect quantities, missing approvals.
Processing: automated workflows, validations, postings
- The system may perform edit checks (required fields, valid vendor IDs), three-way match logic, pricing checks, and posting rules.
- Risks: misconfigured rules, overrides without audit trail, interface failures.
Outputs: reports, ledgers, exception reports, financial statements
- Outputs include trial balances, AP aging, revenue reports, and exception logs.
- Risks: users relying on incomplete reports, access to sensitive outputs, uncontrolled report logic.
Interfaces and integrations
- Modern environments often have multiple systems: point-of-sale to ERP, CRM to billing, warehouse systems to inventory, payroll providers to GL.
- The key control concept is interface control—making sure data transferred between systems is complete, accurate, authorized, and processed once.
Key modules and data structures you should recognize
Even if products differ, common AIS components include:
- General ledger (GL): the central accounting record. Often fed by subledgers.
- Subledgers: Accounts Payable (AP), Accounts Receivable (AR), inventory, fixed assets.
- Master data: vendors, customers, items, chart of accounts.
- Transaction data: invoices, payments, receipts, shipments.
A frequent misconception is that “subledgers are just reports.” Subledgers are usually transaction processing components that feed summarized or detailed postings into the GL. If subledger-to-GL reconciliation fails, financial statements can be wrong even if each subledger seems fine.
Controls in enterprise/AIS environments: where they live
Controls relevant to CPA ISC often fall into two buckets:
Application controls (inside the business process)
- Examples: three-way match, invoice duplicate check, credit limit check, automated pricing validation, required approvals.
- These directly prevent/detect transaction-level errors.
IT general controls (ITGCs) (supporting the reliability of the system)
- Examples: user access provisioning, change management, backups, operations monitoring.
- These establish whether application controls can be trusted over time.
A common exam-style nuance: an application control can be well-designed, but if change management is weak, the control may not be reliable (it could be altered without detection).
Example: procure-to-pay flow in an ERP (showing where problems occur)
Consider a typical procure-to-pay process:
- Purchasing creates a purchase order (PO).
- Goods are received; a receiving document is recorded.
- Vendor invoice is entered.
- System performs a three-way match (PO, receiving, invoice).
- Approved invoices are paid; payment is posted; liabilities reduced.
Where issues happen:
- If vendor master data creation is weak, fake vendors can be added.
- If receiving is not recorded timely, invoices may sit in exceptions and accrue incorrectly.
- If invoice entry allows overrides without logging, someone could bypass matching and pay unauthorized invoices.
Good practice controls include:
- Segregating vendor creation from invoice approval and payment processing,
- Requiring documented approval workflows,
- Maintaining audit trails for overrides and master data changes,
- Reconciling AP subledger to GL.
Exam Focus
- Typical question patterns:
- Map a scenario to a business process (order-to-cash, procure-to-pay, payroll) and identify which system/module is involved.
- Distinguish application controls (e.g., three-way match) from ITGCs (e.g., access provisioning) and explain how they work together.
- Identify interface risks (missing/duplicate transactions) and propose controls (record counts, hash totals, reconciliations, exception handling).
- Common mistakes:
- Assuming “ERP integration” automatically ensures accuracy—interfaces can still fail or be misconfigured.
- Focusing only on transaction controls while ignoring master data governance (vendor/customer/item setup).
- Forgetting reconciliation points (subledger-to-GL, bank recs) that detect processing and interface errors.
I.A.3 Availability
What availability means (and what it does not mean)
Availability is the property of systems and data being accessible and usable when needed by authorized users. In information security, it is one part of the well-known triad alongside confidentiality and integrity.
Availability is not just “the system is up.” It also includes:
- Sufficient performance (not effectively down due to extreme slowness),
- Resilience against failures (hardware faults, software crashes),
- Resilience against attacks (e.g., denial-of-service),
- Operational readiness (people and procedures to restore service).
In an accounting context, availability affects:
- Timely processing (payroll must run on schedule),
- Period-end close (financial reporting deadlines),
- Evidence retention and audit support (can you retrieve logs and records?).
Why availability matters for financial reporting and operations
If key systems are unavailable, the organization may:
- Miss billing cycles (revenue impact),
- Fail to pay vendors on time (cash flow and supplier issues),
- Lose transaction data (incomplete books),
- Perform manual workarounds that introduce errors and control breakdowns.
A subtle control point: during outages, organizations often switch to manual processing. If those manual steps aren’t well-controlled (approvals, logs, reconciliations), the risk of misstatement and fraud increases.
How organizations achieve availability: prevention, detection, recovery
Availability is best taught as a lifecycle:
Design for resilience (prevention)
- Redundancy: multiple components so one failure doesn’t stop service (extra servers, network paths, power supplies).
- High availability (HA): architecture that minimizes downtime—often through clustering and automatic failover.
- Fault tolerance: the ability to continue operating even when components fail (often stronger than basic HA, depending on design).
- Capacity management: ensuring sufficient resources to meet demand (avoids “brownouts” where the system technically runs but can’t be used).
Monitoring and response (detection)
- Continuous monitoring of uptime, errors, job failures, disk space, and security alerts.
- Well-defined incident response so issues are escalated and addressed quickly.
Backup and restoration (recovery)
- Backups are copies of data to restore after loss/corruption.
- Good backup isn’t just making copies—it includes testing restores and securing backup media.
Business continuity and disaster recovery (organizational recovery)
- Business continuity planning (BCP) focuses on keeping critical operations running.
- Disaster recovery (DR) focuses on restoring IT systems after a major disruption.
Two key planning metrics you’ll see in practice:
- RTO (Recovery Time Objective): targeted maximum time to restore service.
- RPO (Recovery Point Objective): targeted maximum data loss measured in time (how far back you might have to recover).
Even if an exam question doesn’t use these acronyms, it may describe them (“system must be back within 4 hours” or “cannot lose more than 15 minutes of transactions”).
Availability threats you should be able to reason about
Availability failures come from many sources:
- Hardware failures (disk crashes, power loss),
- Software failures (bad patches, memory leaks),
- Human error (accidental deletion, misconfiguration),
- Cyber events (ransomware, denial-of-service),
- Third-party outages (cloud region down, telecom provider issues).
A common misconception is to treat availability as purely an “IT operations issue.” In reality, availability is a risk management issue that must align with business needs: a payroll system usually needs higher availability at certain times (pay cycles) than others.
Example: choosing controls based on business needs
Suppose a retailer’s point-of-sale (POS) system is critical during business hours.
- If the POS is down, sales stop—so the business may justify redundant connectivity, local failover modes, and real-time monitoring.
- For a noncritical training portal, the organization may accept longer downtime and use simpler backup/restore without full HA.
This is how availability decisions are made: not every system needs the same level of resilience, but critical financial systems often need strong availability controls.
What goes wrong in availability planning (and how to spot it)
Common failure patterns include:
- Backups exist but restores are untested—so recovery fails when needed.
- “Redundancy” is designed incorrectly (for example, redundant servers in the same data center with the same power dependency).
- DR plans are documented but not exercised; people don’t know roles, dependencies, or access steps.
- During incidents, logs and evidence aren’t preserved, making root-cause analysis and audit support difficult.
Exam Focus
- Typical question patterns:
- Given a scenario (system outage, ransomware, data corruption), identify availability risks and the best control(s): redundancy, monitoring, backups, DR/BCP.
- Interpret RTO/RPO-style requirements embedded in narrative and select an appropriate solution (e.g., frequent backups vs. real-time replication).
- Evaluate whether a described control is actually effective (e.g., backups without restore testing).
- Common mistakes:
- Confusing availability with confidentiality—availability is about access and uptime for authorized users.
- Assuming backups alone guarantee availability; recovery also requires procedures, access, testing, and sometimes alternate infrastructure.
- Ignoring dependencies (DNS, identity services, network connectivity). A system can be “up” but unusable if dependencies fail.
I.A.4 Change management
What change management is
Change management is the set of policies, processes, and controls used to manage modifications to systems in a controlled way. A “change” can include:
- Application code updates,
- Configuration changes (ERP settings, security parameters),
- Database changes (schema modifications),
- Infrastructure changes (server builds, firewall rules),
- Patches and upgrades.
In CPA ISC, change management is a cornerstone IT general control because even well-designed systems become unreliable if changes can be made without authorization, testing, and traceability.
Why it matters: the link to errors, fraud, and audit reliance
Uncontrolled changes can:
- Break processing (jobs fail, interfaces stop),
- Change calculations (tax logic, revenue recognition rules),
- Weaken security (opening ports, disabling logging),
- Enable fraud (altering approval workflows or master data validation rules).
For financial reporting, change management is often the difference between:
- “We can rely on automated controls in the ERP,” and
- “We need more substantive testing because the system might have changed in unknown ways.”
A common misconception is that change management is only about programmers. In reality, many high-risk changes are configuration changes made by functional administrators (e.g., changing tolerance limits for matching, approval thresholds, or posting rules).
How a well-controlled change process works (step by step)
A typical controlled change lifecycle includes:
Request and documentation
- A change begins with a documented change request describing what will change, why, and what systems are affected.
- Good documentation includes backout plans and risk assessment (what could go wrong?).
Authorization and approval
- Appropriate stakeholders review and approve before work begins.
- Approval should match the risk level (minor vs. major change) and should be independent where possible.
Development and configuration
- Work is performed in a controlled environment.
- Developers/admins should not have unnecessary access to production.
Testing
- Testing validates that the change works and doesn’t break other functionality.
- For accounting systems, testing should include business scenarios (posting, reporting, interfaces) and control behaviors (approvals, logs, error handling).
Migration to production (implementation)
- Changes are moved from development/test into production using controlled deployment procedures.
- The goal is to ensure what was tested is exactly what is implemented.
Post-implementation review and monitoring
- Confirm expected results, monitor for incidents, and close the change ticket with evidence.
Segregation of environments and duties: the backbone of change control
Strong change management typically relies on:
- Separate development, test, and production environments.
- Segregation of duties (SoD) so the person who develops a change is not the only one who can approve and implement it.
Why this matters: if a developer can directly change production, they could introduce unauthorized logic—accidentally or intentionally—without detection.
Emergency changes: necessary, but risky
Organizations need a process for emergency changes (e.g., urgent security patches, outage fixes). The control goal is not to block emergency work—it’s to keep it accountable.
A well-controlled emergency change process typically includes:
- Documenting the change and reason,
- Expedited approval by authorized leaders,
- After-the-fact review to confirm testing and proper migration,
- Making sure “emergency” doesn’t become the default path to bypass controls.
Configuration management, patching, and version control
Change management is broader than code releases:
- Configuration management tracks and controls system settings (including baseline configurations).
- Patch management ensures updates (especially security patches) are evaluated, tested when needed, and deployed in a timely way.
- Version control (for code and sometimes configuration) provides traceability—what changed, who changed it, and when.
From an ISC perspective, the key is evidence: can the organization show that changes were authorized, tested, and implemented predictably?
Example: change management failure in an accounting system
Suppose an ERP administrator changes the tolerance setting for three-way match so invoices can be paid even if received quantities don’t match.
- If done without approval and documentation, this is a control breakdown: it weakens a key application control.
- If not tested, it may cause unintended outcomes (e.g., systematically overpaying vendors).
- If not logged and reviewed, you may not detect when and why payments increased.
A controlled approach would require:
- Change request explaining business justification,
- Approval by procurement/AP leadership and possibly internal controls,
- Testing in a nonproduction environment using sample transactions,
- Scheduled deployment and post-change monitoring.
Exam Focus
- Typical question patterns:
- Scenario questions asking which control is missing (approval, testing, segregation, migration control, post-implementation review).
- Evaluate whether an emergency change process is sufficiently controlled (documentation + after-the-fact review).
- Identify risks when developers/admins have production access and propose mitigations (restricted access, logging, independent approvals).
- Common mistakes:
- Treating change management as “only code changes,” ignoring configuration and infrastructure changes that affect financial reporting.
- Assuming testing is optional for small changes—small configuration tweaks can have large downstream effects.
- Forgetting the importance of evidence (tickets, approvals, test results, deployment logs). In control evaluation, “we usually do it” is not the same as “we can demonstrate it.”