Understanding RTGS: ISO 20022 Skills Guide for Developers and Architects

Implementing and operating an RTGS system requires specific ISO 20022 competencies—but not all knowledge is equally valuable. This guide clarifies what RTGS developers and architects actually need to master versus what can remain abstract.

1 The Reality Check

1.1 What Matters vs. What Doesn’t

The Core Principle:

An RTGS developer or architect needs a strong practical understanding of ISO 20022 message usage rather than deep theoretical knowledge of its UML modeling foundations. This distinction shapes everything about how teams should approach learning and implementation.

1.2 Why This Distinction Matters

Many teams make the mistake of over-investing in theoretical ISO 20022 knowledge—spending weeks studying UML profiles, metamodels, and standards governance—when they should be focusing on:

2 Essential Competencies by Role

2.1 Core Developer Skills

Every developer working on RTGS systems should master these fundamentals:

Must-Have Skills:

• Note: The table below provides a proposed example for reading cardinality notation for selected message elements. The specific elements and their cardinalities are illustrative.

┌─────────────────────────────────────────────────────────────┐
│ Element                    │ Cardinality │ Meaning          │
├─────────────────────────────────────────────────────────────┤
│ MsgId                      │ 1           │ Exactly one      │
│ CreDtTm                    │ 1           │ Exactly one      │
│ NbOfTxs                    │ 0..1        │ Zero or one      │
│ CdtTrfTxInf                │ 1..n        │ One or more      │
│ RmtInf                     │ 0..1        │ Optional         │
│ UltmtDbtr                  │ 0..1        │ Optional         │
│ PstlAdr                    │ 0..1        │ Optional         │
│ Ctry                       │ 0..1        │ Optional         │
└─────────────────────────────────────────────────────────────┘

Practical Exercise: Given this pacs.008 snippet, identify validation issues:

• Note: The XML snippet below is a proposed example for a practical exercise. This is a simplified and incomplete pacs.008 message, designed to illustrate common validation issues.

<CdtTrfTxInf>
  <PmtId>
    <!-- TxId is mandatory - missing! -->
    <InstrId>INSTR-001</InstrId>
  </PmtId>
  <!-- IntrBkSttlmAmt is mandatory - missing! -->
  <DbtrAgt>
    <FinInstnId>
      <BICFI>BANKUS33XXX</BICFI>
    </FinInstnId>
  </DbtrAgt>
  <!-- CdtrAgt is mandatory - missing! -->
  <UltmtDbtr>
    <Nm>ABC Corp</Nm>
    <!-- Address is optional - this is valid -->
  </UltmtDbtr>
</CdtTrfTxInf>

2.2 Architect Skills

Architects and senior developers need the above plus strategic understanding: Additional Competencies:

2.3 Skill Matrix Summary

3 Message Families You Must Know

3.1 Primary RTGS Message Families

3.2 Message Usage by RTGS Function

3.3 Deep Dive: pacs.008 Structure

Understanding one message family deeply is better than superficial knowledge of many. Here’s what a developer should know about pacs.008: Key Sections:

• Note: The ASCII art diagram below provides a proposed high-level breakdown of the pacs.008 message structure. This is a simplified representation of the full message and its elements.

pacs.008.001.08
├── GroupHeader (GrpHdr)
│   ├── MsgId          ← Your message identifier (mandatory)
│   ├── CreDtTm        ← Creation timestamp (mandatory)
│   ├── NbOfTxs        ← Transaction count (optional)
│   └── SttlmInf       ← Settlement method (conditional)
│
└── CreditTransferTransactionInformation (CdtTrfTxInf) [1..n]
    ├── PmtId          ← Payment identifiers (mandatory)
    ├── PmtTpInf       ← Payment type (optional)
    ├── IntrBkSttlmAmt ← Amount (mandatory)
    ├── IntrBkSttlmDt  ← Settlement date (mandatory)
    ├── DbtrAgt        ← Debtor agent (mandatory)
    ├── CdtrAgt        ← Creditor agent (mandatory)
    ├── UltmtDbtr      ← Ultimate debtor (optional)
    ├── UltmtCdtr      ← Ultimate creditor (optional)
    └── RmtInf         ← Remittance info (optional)

Critical Validation Points:

4 Message-to-Internal-Model Mapping

4.1 The Mapping Challenge

One of the most critical skills for RTGS developers is translating ISO 20022 messages into internal data models that support:

• Database persistence
• Business logic processing
• API exposure
• Audit logging
• Reporting The Mapping Process:

4.2 Example: Party Information Mapping

ISO 20022 Structure:

• Note: The XML snippet below is a proposed example of ISO 20022 party information structure. This is a simplified representation to illustrate mapping concepts.

<UltmtDbtr>
  <Nm>ABC Corporation</Nm>
  <PstlAdr>
    <StrtNm>Wall Street</StrtNm>
    <BldgNb>100</BldgNb>
    <PstCd>10005</PstCd>
    <TwnNm>New York</TwnNm>
    <Ctry>US</Ctry>
  </PstlAdr>
  <CtryOfRes>US</CtryOfRes>
</UltmtDbtr>

Internal Domain Model:

• Note: The Java code snippet below provides a proposed example of an internal domain model for party information. The specific class structure and fields may vary based on the application’s requirements.

public class Party {
    private String name;
    private Address address;
    private String countryOfResidence;
    private String bic;
    private String lei;
}
public class Address {
    private String streetName;
    private String buildingNumber;
    private String postCode;
    private String townName;
    private String country;
    private List<String> addressLines;  // For unstructured addresses
}

Database Schema:

• Note: The SQL code snippet below provides a proposed example of a database schema for storing party information. The specific table and column definitions may vary based on the database system and ORM used.

CREATE TABLE party (
    id              BIGSERIAL PRIMARY KEY,
    name            VARCHAR(255) NOT NULL,
    bic             VARCHAR(11),
    lei             VARCHAR(20),
    country_of_res  CHAR(2)
);
CREATE TABLE party_address (
    party_id        BIGINT REFERENCES party(id),
    street_name     VARCHAR(140),
    building_number VARCHAR(16),
    post_code       VARCHAR(16),
    town_name       VARCHAR(35),
    country         CHAR(2)
);

Key Considerations:

4.3 Impact of Message Version Changes

When ISO 20022 messages are updated, RTGS teams must assess:

Real-World Example: pacs.008 v08 to v09

5 Object-Oriented Thinking Without UML

5.1 What You Actually Need

You don’t need to draw UML diagrams, but you do need an object-oriented mindset:

Practical Skills:

5.2 Tracing Elements to Business Meaning

When debugging or enhancing systems, you need to trace from technical elements back to business concepts:

┌─────────────────────────────────────────────────────────────────┐
│ Debugging Example: Payment Rejected                             │
├─────────────────────────────────────────────────────────────────┤
│ 1. Technical: pacs.002 status = RJCT                            │
│ 2. Element:   StsRsnInf.Rsn.Cd = "AM04"                         │
│ 3. Business:  "Insufficient amount for settlement"              │
│ 4. Root Cause: Debtor account balance < payment amount          │
│ 5. Action:    Check liquidity management, notify operations     │
└─────────────────────────────────────────────────────────────────┘

This traceability requires understanding what each element represents, not just its technical structure.

6 Learning Priorities and Roadmap

6.1 90-Day Learning Plan

6.2 Recommended Resources

6.3 Common Learning Mistakes

7 Summary

Footnotes for this article: