"Not just Members Only" — A hands-on dive into how IBM's most powerful computers in the world organize, store, and manage data.
███████╗██╗██╗ ███████╗███████╗ ██╗
██╔════╝██║██║ ██╔════╝██╔════╝███║
█████╗ ██║██║ █████╗ ███████╗╚██║
██╔══╝ ██║██║ ██╔══╝ ╚════██║ ██║
██║ ██║███████╗███████╗███████║ ██║
╚═╝ ╚═╝╚══════╝╚══════╝╚══════╝ ╚═╝
IBM Z Xplore | Fundamentals Track
This repository documents my completion of FILES1 — a core challenge in the IBM Z Xplore Fundamentals certification track. The challenge was all about learning how IBM's mainframe operating system (z/OS) stores and organizes data — which is fundamentally different from how a regular Windows or Mac computer does it.
Think of it this way: your laptop stores files in folders. A mainframe stores datasets that can either be read line-by-line (like reading a book from cover to cover) or accessed in any order (like looking up specific chapters in an encyclopedia). This challenge taught me to navigate, manipulate, and manage both of those storage types — using a modern VS Code interface that connects directly to a live IBM Z system running in the cloud.
Why does this matter to your team?
Mainframes process over $10 trillion in financial transactions daily. They power 45 of the world's top 50 banks, 8 out of 10 insurance companies, and 9 out of 10 global payment processors. Someone who can work on this platform is genuinely rare — and that's exactly what this project demonstrates.
| Detail | Value |
|---|---|
| Challenge ID | FILES1 — 250117-1229 |
| Track | IBM Z Xplore Fundamentals |
| Total Steps | 12 |
| Estimated Time | 45 minutes |
| Validation Result | ✅ CC 0000 (Perfect Score) |
| Platform | IBM Z (z/OS) via z/OSMF REST API |
| Tool Used | VS Code + Zowe Explorer Extension |
| Prerequisite Completed | VSC1 ✅ |
Think of these as the real-world abilities this challenge proves I have:
| Skill | What It Means in Plain English |
|---|---|
| Mainframe Dataset Management | I can create, read, rename, copy, and delete data on the world's most reliable computing platform |
| JCL Job Execution | I can submit automated jobs that run programs on the mainframe — like pressing "Run" on a script that controls a billion-dollar system |
| Zowe Explorer Proficiency | I can navigate an IBM Z system through VS Code using the industry-standard open-source tool |
| z/OSMF REST API Interaction | My commands travel securely from my computer to the mainframe via IBM's modern web services layer |
| PDS Member Operations | I can manage partitioned datasets — the mainframe equivalent of folders with organized files inside |
| Sequential Dataset Editing | I can add, modify, and manage records in sequential data files — the backbone of batch processing systems |
| Access Control Awareness | I understand read-only vs. read-write boundaries and how permissions work on enterprise systems |
| Validation & Debugging | I can interpret job completion codes (CC 0000 = success, CC 0127 = something needs fixing) and correct my work accordingly |
How all the pieces connect — from my laptop all the way to IBM's mainframe in the cloud.
flowchart TD
DEV["💻 Developer Workstation\n(VS Code)"]
ZOWE["🔌 Zowe Explorer\n(VS Code Extension)"]
API["🌐 z/OSMF REST API\n(IBM's Secure Web Gateway)"]
Z["🖥️ IBM Z Mainframe\n(z/OS Operating System)"]
PUB["📂 ZXP.PUBLIC\n(Read-Only Shared Space)"]
PRIV["📂 Zxxxxx Private Datasets\n(Your Personal Workspace)"]
JCL["📄 ZXP.PUBLIC.JCL\nPDSBUILD | CHKFILES"]
INPUT["📁 INPUT Dataset (PDS)\nMultiple Members"]
SEQDS["📋 SEQDS Dataset\n(Sequential Records)"]
SURPRISE["🎁 SURPRISE Dataset (PDS)\nHidden Members"]
DEV --> ZOWE
ZOWE -->|"Secure Connection"| API
API -->|"Authentication + Commands"| Z
Z --> PUB
Z --> PRIV
PUB --> JCL
PRIV --> INPUT
PRIV --> SEQDS
PRIV --> SURPRISE
style DEV fill:#007ACC,color:#fff
style ZOWE fill:#054ADA,color:#fff
style API fill:#FF6B35,color:#fff
style Z fill:#1a1a2e,color:#fff
style PUB fill:#e8f4f8,color:#333
style PRIV fill:#e8f8e8,color:#333
style JCL fill:#fff3cd,color:#333
style INPUT fill:#d4edda,color:#333
style SEQDS fill:#d4edda,color:#333
style SURPRISE fill:#d4edda,color:#333
One of the most important things this challenge teaches is that not all data is stored the same way. Here's the breakdown:
flowchart LR
DS["z/OS Data Storage"]
PDS["📁 Partitioned Dataset (PDS)\nLike a folder with files inside"]
SEQ["📋 Sequential Dataset\nLike a single long document"]
PDS --> M1["Member 1\n(e.g. BROWN)"]
PDS --> M2["Member 2\n(e.g. GOLD)"]
PDS --> M3["Member 3\n(e.g. MYNEWMBR)"]
SEQ --> R1["Record 1"]
SEQ --> R2["Record 2"]
SEQ --> R3["Record 3"]
SEQ --> R4["Your New Record ✅"]
DS --> PDS
DS --> SEQ
style DS fill:#054ADA,color:#fff
style PDS fill:#007ACC,color:#fff
style SEQ fill:#FF6B35,color:#fff
| Partitioned Dataset (PDS) | Sequential Dataset (SEQDS) | |
|---|---|---|
| Analogy | A binder with labeled tabs | A scroll you read top to bottom |
| Contents | Multiple named "members" | A single continuous stream of records |
| Best For | Programs, JCL, code modules | Transaction logs, reports, batch output |
| Access Pattern | Random — jump to any member anytime | Sequential — must read from the start |
| Real-World Use | Source code libraries, JCL job decks | Bank statement feeds, audit trails |
| This Challenge Used | INPUT, SURPRISE, ZXP.PUBLIC.JCL | SEQDS |
flowchart TD
S1["🔍 Step 1\nSet Dataset Filter\nZxxxxx + ZXP.PUBLIC"]
S2["👀 Step 2\nView Read-Only Public Datasets"]
S3["⚙️ Step 3\nSubmit PDSBUILD JCL\n(Auto-builds your workspace)"]
S4["🔎 Step 4\nExplore INPUT Dataset Members"]
S5["💾 Step 5\nKnow How to Reset\n(Resubmit PDSBUILD)"]
S6["✏️ Step 6\nRename a Member\nin INPUT Dataset"]
S7["🗑️ Step 7\nDelete a Member\nfrom INPUT Dataset"]
S8["📋 Step 8\nCopy a Member\nfrom SURPRISE Dataset"]
S9["📌 Step 9\nPaste Member\ninto INPUT Dataset"]
S10["📝 Step 10\nAdd a New Record\nto SEQDS Sequential Dataset"]
S11["➕ Step 11\nCreate MYNEWMBR\nin INPUT Dataset"]
S12["🏆 Step 12\nSubmit CHKFILES JCL\nValidate All Work"]
PASS["✅ CC 0000\nCHALLENGE COMPLETE!"]
FAIL["⚠️ CC 0127\nReview and Retry"]
S1 --> S2 --> S3 --> S4 --> S5
S5 --> S6 --> S7 --> S8 --> S9 --> S10 --> S11 --> S12
S12 -->|"All correct"| PASS
S12 -->|"Something missed"| FAIL
FAIL -->|"Fix and resubmit"| S12
style PASS fill:#28a745,color:#fff
style FAIL fill:#dc3545,color:#fff
style S3 fill:#ffc107,color:#333
style S12 fill:#054ADA,color:#fff
IBM Z is famous for being the most secure computing platform on the planet. Here's how security played out in this challenge:
flowchart TD
USER["👤 User (Zxxxxx)"]
RO["🔒 Read-Only Access\nZXP.PUBLIC datasets"]
RW["🔓 Read + Write Access\nZxxxxx private datasets"]
RO --> A1["✅ Can open and read members"]
RO --> A2["✅ Can copy FROM these datasets"]
RO --> A3["❌ Cannot save or edit"]
RO --> A4["✅ Can submit JCL jobs"]
RW --> B1["✅ Can create new datasets"]
RW --> B2["✅ Can rename members"]
RW --> B3["✅ Can delete members"]
RW --> B4["✅ Can paste members into"]
RW --> B5["✅ Can add records to SEQDS"]
USER --> RO
USER --> RW
style USER fill:#054ADA,color:#fff
style RO fill:#dc3545,color:#fff
style RW fill:#28a745,color:#fff
| Security Feature | How It Works | Why It Matters |
|---|---|---|
| User-Scoped Datasets | Each user only sees and edits their own Zxxxxx.* datasets |
Prevents accidental cross-user data corruption |
| Read-Only Public Space | ZXP.PUBLIC is shared but non-editable |
Protects shared templates and JCL from modification |
| z/OSMF REST API Auth | All connections are authenticated through IBM's secure API layer | No direct access — every action is logged and controlled |
| Job Completion Codes | CC 0000 = success, CC 0127 = validation failure |
Built-in automated compliance checking |
| Dataset Attributes | Performance, security, and scalability tuned per dataset | Enterprise data governance at the storage layer |
flowchart LR
subgraph "Local Environment"
VSC["VS Code\n(Editor)"]
ZEXT["Zowe Explorer\n(Extension)"]
end
subgraph "IBM Z Platform"
ZOSMF["z/OSMF\n(REST Gateway)"]
ZOS["z/OS\n(Operating System)"]
JCL["JCL\n(Job Control Language)"]
PDS["PDS\n(Partitioned Datasets)"]
SEQD["Sequential\nDatasets"]
end
VSC --> ZEXT
ZEXT -->|HTTPS REST| ZOSMF
ZOSMF --> ZOS
ZOS --> JCL
ZOS --> PDS
ZOS --> SEQD
style VSC fill:#007ACC,color:#fff
style ZEXT fill:#054ADA,color:#fff
style ZOSMF fill:#FF6B35,color:#fff
style ZOS fill:#1a1a2e,color:#fff
style JCL fill:#ffc107,color:#333
style PDS fill:#28a745,color:#fff
style SEQD fill:#28a745,color:#fff
| Technology | Role | Why It's Used |
|---|---|---|
| IBM z/OS | The mainframe operating system | Runs the world's most critical transaction systems |
| VS Code | Developer IDE | Modern, familiar interface for writing and managing code |
| Zowe Explorer | VS Code extension for IBM Z | Open-source bridge between modern tools and mainframe |
| z/OSMF REST API | Secure communication layer | Allows web-based tools to securely interact with z/OS |
| JCL (Job Control Language) | Mainframe automation language | Submits batch jobs — like a shell script for the mainframe |
| PDS (Partitioned Dataset) | Structured data container | Stores multiple named members for fast random access |
| Sequential Dataset | Linear data file | Optimized for high-speed batch record processing |
Every operation I performed on this challenge, mapped to its real-world enterprise equivalent:
| Step | Operation | Dataset | Mainframe Skill | Enterprise Equivalent |
|---|---|---|---|---|
| 1 | Set search filter | ZXP.PUBLIC + Zxxxxx | Dataset exploration | Navigating production storage |
| 2 | Browse read-only datasets | ZXP.PUBLIC | Access control awareness | Auditing shared resources |
| 3 | Submit PDSBUILD JCL |
ZXP.PUBLIC.JCL | JCL job submission | Running automated provisioning |
| 4 | Explore INPUT members | Zxxxxx.INPUT | PDS member browsing | Reviewing source code libraries |
| 5 | Reset mechanism | ZXP.PUBLIC.JCL | Idempotent job design | Disaster recovery awareness |
| 6 | Rename member | Zxxxxx.INPUT | Member rename | Refactoring module names |
| 7 | Delete member | Zxxxxx.INPUT | Member deletion | Cleaning up old deployments |
| 8 | Copy member | Zxxxxx.SURPRISE | Cross-dataset copy | Promoting code between environments |
| 9 | Paste member | Zxxxxx.INPUT | Member paste | Deploying to target environment |
| 10 | Add record | Zxxxxx.SEQDS | Sequential file editing | Appending to transaction logs |
| 11 | Create new member | Zxxxxx.INPUT | Member creation | Scaffolding new code modules |
| 12 | Submit CHKFILES JCL |
ZXP.PUBLIC.JCL | Validation job execution | Running automated test suites |
At the end of the challenge, here's exactly what my mainframe workspace looked like:
flowchart TD
WS["📦 Zxxxxx Workspace\n(Final State)"]
INPUT["📁 INPUT Dataset (PDS)\n5 Members Total"]
SEQDS["📋 SEQDS Sequential Dataset\nOriginal Records + 1 New"]
SURPRISE["🎁 SURPRISE Dataset (PDS)\nRead-Only Source"]
INPUT --> C1["🟤 Color Member 1\n(Original)"]
INPUT --> C2["🟡 Color Member 2\n(Original)"]
INPUT --> C3["✏️ Renamed Member\n(Step 6 - Renamed from M-something)"]
INPUT --> C4["📋 Copied Member\n(Step 9 - Pasted from SURPRISE)"]
INPUT --> C5["➕ MYNEWMBR\n(Step 11 - Created from scratch)"]
SEQDS --> R1["Line 1 - Original Record"]
SEQDS --> R2["Line 2 - Original Record"]
SEQDS --> R3["Line 3 - Original Record"]
SEQDS --> R4["Line 4 - Original Record"]
SEQDS --> R5["Line 5 - Original Record"]
SEQDS --> R6["✅ Line 6 - Your New Record"]
WS --> INPUT
WS --> SEQDS
WS --> SURPRISE
style WS fill:#054ADA,color:#fff
style INPUT fill:#28a745,color:#fff
style SEQDS fill:#28a745,color:#fff
style SURPRISE fill:#6c757d,color:#fff
style C3 fill:#ffc107,color:#333
style C4 fill:#17a2b8,color:#fff
style C5 fill:#28a745,color:#fff
style R6 fill:#28a745,color:#fff
Here's the exact sequence of what happens every time I interact with the mainframe — visualized as a conversation between systems.
sequenceDiagram
participant Dev as 💻 Developer
participant VSC as VS Code
participant Zowe as Zowe Explorer
participant API as z/OSMF REST API
participant Z as IBM Z Mainframe
Dev->>VSC: Open Zowe Explorer panel
VSC->>Zowe: Initialize connection profile
Zowe->>API: Authenticate (HTTPS)
API->>Z: Verify credentials
Z-->>API: Access granted
API-->>Zowe: Session token returned
Zowe-->>Dev: Dataset tree loaded
Dev->>Zowe: Set filter Zxxxxx + ZXP.PUBLIC
Zowe->>API: GET datasets matching filter
API->>Z: Query catalog
Z-->>Dev: Dataset list displayed
Dev->>Zowe: Right-click PDSBUILD → Submit Job
Zowe->>API: POST JCL job submission
API->>Z: Execute PDSBUILD batch job
Z-->>Dev: INPUT, SEQDS, SURPRISE created
Dev->>Zowe: Rename, Delete, Copy, Paste members
Zowe->>API: PUT/DELETE/POST member operations
API->>Z: Execute dataset modifications
Z-->>Dev: Operations confirmed
Dev->>Zowe: Right-click CHKFILES → Submit Job
Zowe->>API: POST validation job
API->>Z: Run CHKFILES validation
Z-->>Dev: CC 0000 - All steps verified!
pie title Skills Demonstrated in FILES1
"Mainframe Dataset Navigation" : 20
"JCL Job Execution" : 20
"Access Control Understanding" : 15
"PDS Member Operations" : 20
"Sequential Dataset Editing" : 15
"Validation and Debugging" : 10
Here's the honest truth about mainframe skills in 2025:
There are approximately 250,000 COBOL developers worldwide — and the average age is over 55.
Companies running z/OS systems are facing a critical talent shortage, and most of the people who know this platform are retiring.
I'm not just learning mainframe because it's interesting — I'm learning it because it's strategically valuable. Very few full-stack engineers ever touch a mainframe. I have, and I can navigate it with modern tools (VS Code, Zowe, REST APIs) while also understanding the legacy architecture underneath.
What this means for your organization:
- 🧩 I can bridge the gap between modern cloud-native development and legacy mainframe systems
- 🔒 I understand enterprise-grade security and access control patterns
- ⚡ I can work in both the modern toolchain (VS Code, Git, Docker) and the mainframe ecosystem (JCL, z/OS, COBOL)
- 🛠️ I debug systematically — read the return code, understand what failed, fix it, and resubmit
- 📖 I don't just follow instructions — I understand why each step matters
If you want to run this yourself through IBM Z Xplore:
# Prerequisites
# 1. Register at https://ibmzxplore.influitive.com/
# 2. Complete VSC1 challenge first
# 3. Install VS Code: https://code.visualstudio.com/
# 4. Install Zowe Explorer extension in VS Code
# Connection Setup
# Profile Name: zxplore
# Host: (provided by IBM Z Xplore)
# Port: 443 (HTTPS)
# Username: Zxxxxx (your assigned ID)
# Authentication: Password via z/OSMFStep-by-step:
- Set filter to
Zxxxxx , ZXP.PUBLICin Zowe Explorer - Submit
PDSBUILDfromZXP.PUBLIC.JCL - Complete all 12 operations (rename, delete, copy, paste, edit, create)
- Submit
CHKFILESand confirmCC 0000
I'm a Senior Full-Stack Engineer with 9+ years of experience building high-throughput payment infrastructure and distributed systems in Go, Python, and SQL. I'm currently pursuing IBM Z expertise as part of a deliberate strategy to become one of the rare engineers who can operate at both the cloud-native and mainframe layers of enterprise architecture.
My background in payment systems, WebSocket servers, database optimization, and AWS cloud architecture gives me a unique foundation for enterprise mainframe work — I don't just know the commands, I understand the why behind distributed, high-reliability system design.
Languages & Tools: Go · Python · COBOL · JCL · SQL · AWS · Docker · Redis · VS Code · Zowe · z/OS
IBM Z Xplore | Copyright IBM 2021–2024 | FILES1-250117-1229