Mainframe Path Start learning free

Free mainframe lessons

46 subjects and 160 lessons, written in plain English for beginners and early-career mainframers. Read any lesson here, or open it in the app to take the quiz and track your progress.

What is a mainframe?

Start here. What the machine actually is, why banks and insurers still run on it, and the two shapes almost all mainframe work takes.

  1. What a mainframe actually is
  2. Why organisations still run them
  3. The stack, from metal to your program
  4. Batch and online: the two shapes of work

z/OS fundamentals

The operating system almost all of this runs under: how work is isolated, how it gets scheduled, and how you watch it happen.

  1. What z/OS does for you
  2. How a job becomes running work: JES2
  3. SDSF: watching the system
  4. Reading z/OS messages and codes

TSO/ISPF navigation

The green screen, demystified. How to log on, read a panel, find your files, and edit them without fear.

  1. TSO, ISPF and the terminal
  2. Reading an ISPF panel
  3. Option 3.4: finding and handling datasets
  4. The ISPF editor, properly

JCL

Job Control Language is how you tell z/OS to run something. Three statement types do almost all the work, and DISP causes almost all the trouble.

  1. What JCL is for
  2. The JOB and EXEC statements
  3. DD statements: connecting programs to data
  4. DISP, the parameter that causes the most trouble
  5. Procedures, symbols and overrides

Datasets and catalog concepts

Files on z/OS are not files. They have names with rules, a shape declared up front, and a catalog that turns a name into a location.

  1. Dataset names and what they tell you
  2. Sequential, partitioned, and the rest
  3. Catalogs: how a name becomes a location
  4. The utilities that move data around

COBOL basics

The language most business logic on this platform is written in. Verbose on purpose, strict about data, and much easier to read than to write.

  1. Why COBOL still, and what it is good at
  2. The four divisions
  3. PICTURE clauses and how data is stored
  4. Logic, files and calling other programs
  5. Compile, link, run — and debugging S0C7

DB2 basics

Relational data on z/OS. Familiar SQL, unfamiliar packaging: your SQL is compiled ahead of time and bound into a package before it ever runs.

  1. What DB2 for z/OS is
  2. Embedded SQL, precompile and BIND
  3. SQLCODEs and what to do about them
  4. Commits, locking and why batch jobs collide

CICS basics

The transaction server that runs the online side of the business. Small programs, many users, and a programming model shaped entirely by not making anyone wait.

  1. What CICS is and how work arrives
  2. Pseudo-conversational programming
  3. The commands and abends you will meet
  4. Screens, maps and the modern front ends

VSAM basics

The indexed file organisation behind a great deal of online data. Four types, one that matters most, and one utility that does everything.

  1. The four VSAM types
  2. IDCAMS: define, load, inspect
  3. Using VSAM from a program

Unix System Services

A full POSIX environment inside z/OS. If you know Linux, most of it is familiar — but the joins between the Unix world and the MVS world are where the interesting problems live.

  1. z/OS Unix in one page
  2. Working across the two worlds
  3. Where modern tooling fits

REXX scripting on z/OS

The mainframe's everyday scripting language. Automate TSO and ISPF tasks, read and write datasets, run TSO commands in batch, and write ISPF edit macros.

  1. Your first REXX exec
  2. Decisions, loops and PARSE
  3. Datasets and TSO commands from REXX
  4. ISPF edit macros and error handling

Security and RACF fundamentals

Every access on this platform is checked. Understanding who you are, what you are in, and what is protected explains most of the errors you will hit.

  1. Users, groups and profiles
  2. Reading a violation and asking for the right thing
  3. Working safely in a regulated environment

Operations, scheduling and production support

The job most people actually get hired into. What the overnight looks like, how to triage a failure at three in the morning, and how to restart without making it worse.

  1. What production support actually is
  2. The batch schedule and the critical path
  3. Triage: an abend at three in the morning
  4. Rerun, restart, and not making it worse
  5. Change, incidents and doing this sustainably

Batch operations and workload schedulers

How overnight batch is planned, run and repaired with the schedulers banks actually use: Control-M, IBM Z Workload Scheduler (TWSz), IBM Workload Scheduler (IWS) with the Dynamic Workload Console, AutoSys, Stonebranch and others.

  1. How workload scheduling works
  2. Control-M
  3. IBM Z Workload Scheduler, IWS and DWC
  4. AutoSys, Stonebranch and other schedulers
  5. Running and fixing a batch night

DevOps and CI/CD on z/OS

How mainframe teams move from manual promotion and change windows to Git, automated builds, tests and deployments — and which old ideas map onto which new tools.

  1. Why mainframe teams adopt CI/CD
  2. Source control: from PDS members to Git
  3. Building COBOL in a pipeline
  4. Automated testing on z/OS
  5. Deploying safely to production

APIs and REST on z/OS

How mobile apps and websites talk to CICS, IMS and DB2 programs through REST APIs: HTTP and JSON in plain terms, mapping copybooks to JSON, exposing and calling APIs, and keeping them secure.

  1. REST in plain terms
  2. From copybook to JSON
  3. Exposing CICS and IMS programs as APIs
  4. Calling external APIs from COBOL
  5. Securing and running mainframe APIs

Interview and career preparation

How mainframe roles are structured, what interviews actually ask, and how to build credible experience when you do not have a mainframe at work.

  1. The roles, and which one to aim at
  2. The questions you will be asked
  3. Building experience without a mainframe
  4. Your first 90 days

IBM MQ messaging

How applications on and off the mainframe hand work to each other reliably with IBM MQ: queue managers, queues, channels, the MQI calls COBOL programs use, and what to check when messages stop flowing.

  1. Why messaging exists
  2. Queue managers, queues and channels
  3. Programming with the MQI in COBOL
  4. Running and troubleshooting MQ

IMS database and transactions

IMS is IBM's hierarchical database and transaction manager, still running core systems at many banks, insurers and governments. Learn how its data is shaped, how COBOL programs read and update it with DL/I calls, and how IMS is operated.

  1. What IMS is and where it runs
  2. Hierarchical data: segments, DBDs and PSBs
  3. DL/I calls from COBOL
  4. IMS in production

Workload Manager (WLM)

How z/OS decides which work gets the processor, memory and I/O first: business goals, service classes, importance and classification rules, and how to tell from SDSF and RMF whether work is meeting its goals.

  1. What WLM does
  2. Service classes, goals and classification
  3. WLM in production

z/OS utilities

The IBM-supplied programs that create, copy, compare, list, sort and back up data without writing a line of code. Learn the control statements, what the return codes really mean, and how each utility is used in production JCL.

  1. How utilities work: IEFBR14, IEBGENER and IDCAMS
  2. Libraries, comparisons and volumes: IEBCOPY, IEBCOMPR, IEHLIST and ADRDSSU
  3. DFSORT and ICETOOL in production

JES2 and SDSF in depth

Follow a batch job through every JES2 phase, from input to purge. Learn how job classes, initiators, output classes and the spool fit together, which JES2 commands do what, how to work SDSF properly, and how sites handle a spool that is filling up.

  1. The life of a job inside JES2
  2. Spool, output and the main JES2 commands
  3. Working in SDSF and handling spool problems

Storage management (DFSMS)

How z/OS decides where data lives and how it is looked after: DFSMS components, SMS classes and ACS routines, DFSMShsm migration and backup, tape and virtual tape, copy services, and the space problems you will meet in production.

  1. DFSMS components and SMS constructs
  2. DFSMShsm, tape and virtual tape
  3. Copy services, storage problems and the storage role

z/OS networking: TCP/IP and SNA

How z/OS talks to the world: Communications Server, the TCP/IP stack and OSA adapters, VIPA and Sysplex Distributor, the TN3270 server behind every green screen, SNA and VTAM basics, and a layered way to troubleshoot connections.

  1. Communications Server and the TCP/IP stack
  2. VIPA, Sysplex Distributor and the TN3270 server
  3. SNA and VTAM basics, and troubleshooting connectivity

SMF and RMF

z/OS records almost everything it does as SMF records. Learn the key record types, how SMF is collected and archived, how RMF measures performance, and how the data feeds chargeback, capacity planning and audit.

  1. What SMF records
  2. Collecting, dumping and archiving SMF
  3. RMF and putting SMF to work

Performance and capacity management

Why work is slow and how much the machine can take. Response time and throughput, CPU, I/O and storage bottlenecks, MSU and the four-hour average, capping and software cost, capacity planning, batch window tuning and a method for investigating problems.

  1. Response time, throughput and bottlenecks
  2. MSU, capping and capacity planning
  3. Investigating performance problems

Parallel Sysplex

How several z/OS systems act as one: XCF and couple data sets, the coupling facility and its lock, cache and list structures, shared time, Db2/IMS/VSAM/MQ data sharing, rolling IPLs, GDPS at concept level, and the problems you will meet on call.

  1. From one system to many: sysplex, XCF and couple data sets
  2. The coupling facility and data sharing
  3. Continuous availability: balancing, rolling IPLs, GDPS and common problems

SMP/E and software maintenance

How z/OS and its products are installed and kept current: SYSMODs, the CSI and its zones, RECEIVE, APPLY, ACCEPT and RESTORE, HOLDDATA, APPLY CHECK, target and distribution libraries, RSU service levels and the change control around them.

  1. Why SMP/E exists: SYSMODs and the CSI
  2. RECEIVE, APPLY, ACCEPT and RESTORE
  3. Service levels, RSUs and change control for maintenance

Advanced COBOL

Beyond the basics: how COBOL programs call each other, what Language Environment does underneath them, which compiler options change production behaviour, and how to debug, tune, test and maintain code that has to keep running for decades.

  1. Subprograms, CALL linkage and nested programs
  2. Language Environment and production compiler options
  3. Debugging, performance, JSON/XML and maintainable code

PL/I fundamentals

PL/I is the other big business language on z/OS, still running core systems at banks, insurers and utilities. Learn how programs are structured, how data is declared, how ON-units handle errors and end of file, and how to read PL/I if you come from COBOL.

  1. Where PL/I is used and how a program is built
  2. PL/I data types, structures and built-in functions
  3. ON-units, file I/O and running PL/I on z/OS

Assembler (HLASM) fundamentals

The machine's own language, made readable. Why assembler still runs exits and critical modules, how registers and base addressing work, the instructions and linkage you will meet most, and how to read assembler in a dump.

  1. Why assembler still matters: registers and addressing
  2. Common instructions and linkage conventions
  3. Storage definitions, dumps and program checks

Advanced DB2

Beyond SQL: how DB2 for z/OS chooses access paths and how to read EXPLAIN, indexing and statistics, the REORG, COPY, LOAD and RECOVER utilities, buffer pools, locking, data sharing and the traces you use to find where time goes.

  1. Access paths, EXPLAIN, indexes and statistics
  2. Utilities, backup and recovery
  3. Buffer pools, locking, data sharing and troubleshooting

Advanced CICS

Beyond the single region: how production CICS is laid out across many regions, how resources are defined, how data survives failures, what threadsafe really means, and how to keep a busy region healthy and find the cause when it is not.

  1. Regions, topology and resource definitions
  2. Recovery, threadsafe and modern interfaces
  3. Performance, monitoring and troubleshooting

Mainframe security engineering

The next step after RACF basics: how SAF and the three security managers compare, how certificates, AT-TLS and pervasive encryption protect data, and how auditing, privileged access control and incident handling work in a regulated shop.

  1. SAF and the three security managers
  2. Certificates, TLS and encryption
  3. Auditing, privileged access and security operations

Incident, problem and change management

How production teams handle outages and stop them recurring: incident lifecycle and severity, restoring service first, blameless post-incident reviews, root cause versus contributing factors, safe change with back-out plans and freezes, runbooks and operations automation.

  1. Incidents, severity and restoring service
  2. Problem management and blameless review
  3. Change management, runbooks and automation

Disaster recovery and business continuity

How mainframe sites survive losing a data centre or having data corrupted: RPO, RTO and business impact analysis, synchronous and asynchronous replication, backups and virtual tape, GDPS at concept level, consistent recovery of subsystems and batch, and realistic DR testing.

  1. RPO, RTO and business impact
  2. Replication, backups, tape and GDPS
  3. Recovering consistently and testing DR

Zowe, VS Code and Git

Work on z/OS from a normal PC: what Zowe is, how Zowe Explorer and Zowe CLI reach datasets, jobs and Unix files through z/OSMF, how VS Code language extensions help with COBOL and JCL, and how mainframe source fits into Git.

  1. What Zowe is and how it connects
  2. Datasets, jobs and USS files from your PC
  3. Git workflows for mainframe source

Mainframe observability

How to see what z/OS work is doing and why: metrics, logs and traces from SMF, RMF, OPERLOG and product monitors, feeding them into enterprise platforms, golden signals, alerts people trust, and tracing a transaction from a phone app into CICS and DB2.

  1. Monitoring, observability and z/OS telemetry
  2. Getting mainframe data into enterprise platforms
  3. Golden signals, alerts and end-to-end tracing

Linux on Z and containers

The same mainframe hardware that runs z/OS also runs ordinary Linux. Learn what IFLs and LinuxONE are, how z/VM and KVM host Linux guests, what s390x means for your software, how containers and OpenShift fit, and when Linux on Z is the wrong answer.

  1. Linux on the mainframe: IFLs and LinuxONE
  2. Hosting Linux: LPARs, z/VM, KVM and s390x
  3. Containers, OpenShift and co-location with z/OS

Application discovery and dependency analysis

Before you change or modernize a mainframe application you need to know what it really contains and what depends on what. Learn to inventory programs, copybooks, JCL, datasets, Db2 tables and transactions, build call graphs and data lineage, find dead code and turn the evidence into a backlog.

  1. Why discovery comes first: building the inventory
  2. Call graphs, data lineage and impact analysis
  3. Dead code, tools and building the backlog

COBOL refactoring and incremental modernization

How teams modernize COBOL systems without betting the business: choosing between retain, refactor, replatform, rewrite and replace, strangling old code behind APIs and events, refactoring safely with tests, and the real risks of converting COBOL to Java.

  1. Choosing a modernization strategy
  2. Strangler fig, APIs first and event-driven integration
  3. Refactoring COBOL safely and COBOL-to-Java risks

Data modernization

How mainframe data reaches modern systems without losing accuracy or control: moving VSAM and IMS data to relational tables, replication and change data capture, virtualization and streaming for analytics, EBCDIC and packed-decimal pitfalls, and keeping one system of record.

  1. From VSAM and IMS to relational
  2. Replication, change data capture and analytics access
  3. Conversion pitfalls, quality, governance and the system of record

AI-assisted code analysis and testing

How to use AI assistants to explain COBOL and JCL, draft documentation, support impact analysis and generate tests and test data — and how to verify the results, because fluent answers are not the same as correct ones.

  1. Explaining and documenting code with AI
  2. Generating unit tests and test data
  3. Grounding, verification and failure modes

AI governance for mainframe teams

The rules that let mainframe teams use AI tools safely: keep production data and secrets out of prompts, use approved tools, keep a human accountable, make AI-assisted changes auditable, measure benefit honestly and stay aware of regulation.

  1. Data privacy and security with AI tools
  2. Accountability, audit and change control
  3. Team policy, honest measurement and regulation

High availability and DR architecture

How mainframe estates are designed to stay up and to come back: removing single points of failure with Parallel Sysplex, choosing DR topologies and replication against RPO and RTO, keeping batch and online data consistent, and proving it all with tests.

  1. Designing for continuous availability
  2. DR topologies and replication choices
  3. Consistency, testing and cost trade-offs

Hybrid cloud and enterprise integration architecture

How to connect the mainframe to everything else on purpose: choosing between APIs, MQ, events, file transfer and replication, securing identity and data across tiers, controlling latency and MIPS cost, and the hybrid cloud patterns that keep z/OS as the system of record.

  1. Integration styles and how to choose
  2. Security and performance across tiers
  3. Hybrid cloud patterns and governance