From the free course Computer Applications and Information Technology on Lykke

Systems Analysis, Design, and Security

Key concepts: Systems Analysis and Design · Cybersecurity · Risk Management · Enterprise Security · Data Privacy

The lifecycle of information systems development and the critical role of cybersecurity and risk management.

Systems Analysis, Design, and Security

The modern enterprise is a complex tapestry of hardware, software, data, and human processes. Building and maintaining these systems is not merely a task of writing code; it is a rigorous discipline of Systems Analysis and Design (SAD), underpinned by a robust framework of Cybersecurity and Risk Management. In an era where data is the primary currency, the integration of security into the very architecture of a system—rather than as an afterthought—is the hallmark of professional engineering.

This article explores the methodologies used to analyze business needs, the architectural principles of system design, and the multi-layered security strategies required to protect organizational assets in a globalized, digital economy.

The Foundations of Systems Analysis and Design (SAD)

Systems Analysis and Design is the process of examining a business situation, identifying opportunities for improvement, and designing an information system to address those needs. It bridges the gap between business requirements and technical implementation.

The Systems Development Life Cycle (SDLC)

The SDLC is a conceptual model used in project management that describes the stages involved in an information system development project, from an initial feasibility study through maintenance of the completed application.

Phase Primary Goal Key Deliverable
Planning Determine why the system should be built. Feasibility Study / Project Plan
Analysis Determine who will use the system, what it will do, and where/when it will be used. System Proposal / Requirements Doc
Design Determine how the system will operate (Hardware, Software, Network). System Specification / Architecture
Implementation Build, test, and install the system. Working System / Documentation
Maintenance Support the system and handle updates/bugs. Support Logs / Version Updates

Definition: Systems Analysis is the "what" (defining requirements), while Systems Design is the "how" (defining the technical solution).

Methodological Perspectives: Waterfall vs. Agile

The choice of methodology dictates the flow of the SDLC. While Waterfall is linear and structured, Agile is iterative and incremental.

Feature Waterfall Agile
Flexibility Rigid; changes are difficult and costly. Highly flexible; embraces changing requirements.
Requirement Definition Defined upfront in detail. Evolve through iterations (Sprints).
Risk High; issues may not be found until the end. Low; continuous testing and feedback.
Best For Stable environments with clear requirements. Dynamic environments with evolving needs.

Systems Design: Architecture and Organization

Systems design translates the "what" into a blueprint. This involves two distinct but related concepts: Computer Architecture and Computer Organization.

  • Computer Architecture refers to those attributes of a system visible to a programmer, or, those attributes that have a direct impact on the logical execution of a program (e.g., instruction sets, bit numbering).
  • Computer Organization refers to the operational units and their interconnections that realize the architectural specifications (e.g., hardware details like control signals, interfaces).

Data Management and Database Design

A core component of design is the Database Management System (DBMS). Effective design requires Normalization—the process of organizing data to minimize redundancy and dependency.

-- Example: Implementing Role-Based Access Control (RBAC) in a System Design
-- This schema ensures that security is baked into the data model.

CREATE TABLE Users (
    user_id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    password_hash CHAR(64) NOT NULL, -- SHA-256
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE Roles (
    role_id INT PRIMARY KEY AUTO_INCREMENT,
    role_name VARCHAR(20) NOT NULL
);

CREATE TABLE User_Roles (
    user_id INT,
    role_id INT,
    PRIMARY KEY (user_id, role_id),
    FOREIGN KEY (user_id) REFERENCES Users(user_id),
    FOREIGN KEY (role_id) REFERENCES Roles(role_id)
);

-- Query to check if a user has 'Admin' privileges
SELECT u.username 
FROM Users u
JOIN User_Roles ur ON u.user_id = ur.user_id
JOIN Roles r ON ur.role_id = r.role_id
WHERE u.username = 'sys_admin' AND r.role_name = 'Admin';

Cybersecurity: The Defense of Information Systems

Cybersecurity is the practice of protecting systems, networks, and programs from digital attacks. These attacks are usually aimed at accessing, changing, or destroying sensitive information, extorting money from users, or interrupting normal business processes.

The CIA Triad

The cornerstone of security is the CIA Triad:

  1. Confidentiality: Ensuring that data is accessible only to those authorized to have access.
  2. Integrity: Ensuring that data is accurate and has not been tampered with.
  3. Availability: Ensuring that systems and data are available to authorized users when needed.

Defense in Depth

A "silver bullet" for security does not exist. Instead, engineers employ Defense in Depth, a strategy that uses multiple layers of security controls throughout an IT system.

  • Physical Layer: Biometrics, locks, and security guards.
  • Network Layer: Firewalls, IDS/IPS, and VPNs.
  • Host Layer: Antivirus, patch management, and OS hardening.
  • Application Layer: Input validation, encryption, and secure coding.

Secure Coding and Implementation

Implementation is where the design becomes reality. To prevent vulnerabilities like buffer overflows or SQL injection, developers must adhere to secure coding standards.

/* 
 * Low-level Implementation: Secure String Handling in C
 * Demonstrating the prevention of Buffer Overflow, a common system vulnerability.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_BUFFER 1024

void secure_copy(const char *input) {
    char buffer[MAX_BUFFER];

    // INSECURE: strcpy(buffer, input); 
    // This could overflow if input > 1024 bytes.

    // SECURE: strncpy with explicit null termination
    strncpy(buffer, input, MAX_BUFFER - 1);
    buffer[MAX_BUFFER - 1] = '\0'; 

    printf("Buffer safely contains: %s\n", buffer);
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Usage: %s <string>\n", argv[0]);
        return 1;
    }
    secure_copy(argv[1]);
    return 0;
}

Risk Management and Enterprise Security

Risk Management is the process of identifying, assessing, and controlling threats to an organization's capital and earnings. In IT, this means balancing the cost of security controls against the value of the assets being protected.

The Risk Assessment Formula

Risk is often quantified using the following relationship:

$$Risk = Probability \times Impact$$

Where:

  • Probability: The likelihood of a threat occurring.
  • Impact: The cost (financial, reputational, legal) if the threat occurs.

Risk Response Strategies

Organizations typically choose one of four ways to handle a risk:

Strategy Description Example
Avoidance Eliminating the cause of the risk. Discontinuing a high-risk service.
Mitigation Reducing the probability or impact. Installing a firewall.
Transfer Moving the risk to a third party. Purchasing cybersecurity insurance.
Acceptance Acknowledging the risk and doing nothing. Accepting the risk of a minor, rare glitch.

Data Privacy, Ethics, and Governance

As systems become more integrated, the ethical and legal implications of data usage grow. IT Governance provides a framework to ensure that IT investments support business objectives while managing risks and meeting legal requirements.

Privacy Frameworks and Laws

Modern systems must comply with various regulations:

  • GDPR (General Data Protection Regulation): Focuses on data protection and privacy for all individuals within the EU.
  • HIPAA: Governs the protection of medical information in the US.
  • CCPA: Enhances privacy rights and consumer protection for residents of California.

Ethical Considerations in System Design

Engineers must consider the social implications of their work. This includes Web Accessibility (ensuring systems are usable by people with disabilities) and Information Literacy (ensuring users can effectively find and evaluate information).

# Data Privacy: Simple Anonymization Script
# Demonstrating the 'Privacy by Design' principle by masking PII (Personally Identifiable Information).

import pandas as pd
import hashlib

def anonymize_data(df, columns_to_mask):
    """
    Masks sensitive columns using SHA-256 hashing to preserve 
    data utility for analysis while protecting identity.
    """
    for col in columns_to_mask:
        df[col] = df[col].apply(lambda x: hashlib.sha256(str(x).encode()).hexdigest())
    return df

# Realistic usage
data = {
    'Name': ['Alice Smith', 'Bob Jones'],
    'Email': ['alice@example.com', 'bob@example.com'],
    'Purchase_Amount': [150.00, 200.50]
}

df = pd.DataFrame(data)
anonymized_df = anonymize_data(df, ['Name', 'Email'])

# The output preserves the relationship between records without exposing names/emails
print(anonymized_df)

Modern Integration: DevSecOps

The contemporary approach to systems development is DevSecOps, which integrates security practices into the DevOps pipeline. This ensures that security checks are automated and performed continuously rather than just at the end of the development cycle.

# Real-world Usage: GitHub Actions Workflow for Security Scanning
# This snippet automates Static Analysis Security Testing (SAST).

name: Security Scan

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  snyk-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run Snyk to check for vulnerabilities
        uses: snyk/actions/python@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          args: --severity-threshold=high

Common Pitfalls in Systems Analysis and Security

  1. Scope Creep: Allowing the system requirements to grow uncontrollably during the SDLC without adjusting time and budget.
  2. Security Through Obscurity: Relying on the secrecy of the design or implementation as the main security method. This is a fallacy; robust systems are secure even if the attacker knows how they work (Kerckhoffs's Principle).
  3. Neglecting the "Human Element": Most security breaches occur through Social Engineering (phishing, baiting) rather than technical exploits. User education is as critical as a firewall.
  4. Underestimating Technical Debt: Rushing the implementation phase of the SDLC often leads to "spaghetti code" that is difficult to secure and maintain later.

Conclusion

Systems Analysis, Design, and Security are not isolated tasks but are deeply interconnected. A well-analyzed system is easier to design; a well-designed system is inherently more secure; and a secure system is more resilient to the risks of the modern digital landscape. By following structured methodologies like the SDLC and adhering to principles like Defense in Depth and Privacy by Design, organizations can build robust infrastructures that provide a strategic advantage in a globalized world.

Systems Analysis, Design, and Security - Computer Applications and Information Technology - image 1
Systems Analysis, Design, and Security - Computer Applications and Information Technology - image 1
Systems Analysis, Design, and Security - Computer Applications and Information Technology - diagram 1
Systems Analysis, Design, and Security - Computer Applications and Information Technology - diagram 1
Systems Analysis, Design, and Security - Computer Applications and Information Technology - diagram 2
Systems Analysis, Design, and Security - Computer Applications and Information Technology - diagram 2

Source Materials

Study Computer Applications and Information Technology on Lykke

This course page is free to open: signed out, you can read its first two sections, and signing in, on any plan, opens the rest. The free Lykke Chrome extension syncs your own Canvas courses, so ChatGPT, Claude and Muse can answer from your classes and deadlines. It only reads Canvas.

Add the free extensionSign in to open every section

All sections of Computer Applications and Information Technology · Browse more course pages

Systems Analysis, Design, and Security — Computer Applications and Information Technology | Lykke