sp/ARCHITECT was a pioneering electronic banking and funds-transfer software suite. Originally built by the UK-based Software Partnership (TSP), it ran natively on fault-tolerant Tandem (now HPE NonStop) systems. It provided highly available transaction routing and real-time electronic book-keeping for major international financial institutions.
Detailed Timeline by Era and Year
1. The Genesis & Independent Era (Mid-1980s – 1989)
Mid-1980s: The Software Partnership (TSP) is co-founded in Timperley, UK. Development begins on sp/ARCHITECT, designed with a client-server architecture.
1986: Tandem launches NonStop SQL, providing the underlying high-availability relational database foundation that sp/ARCHITECT relied upon to ensure absolute data integrity for banks.
2. Mainstream Banking Adoption Era (1990 – 1994)
1990: TSP relocates to Norton House in Runcorn, UK. sp/ARCHITECT achieves production deployment and is widely utilized for inter-account transfers and book-keeping by major banks like TSB and Bank of Scotland.
1992: Due to rapid expansion, the Runcorn operations relocate to Wingate House.
1994: Deluxe Electronic Payment Systems (a subsidiary of Deluxe Corporation) acquires TSP to expand its global electronic funds transfer (EFT) footprint. The platform is globally marketed and supported, expanding to clients like Rabobank.
1990: TSP relocates to Norton House in Runcorn
1992: Due to rapid expansion, the Runcorn operations relocate to Wingate House.
3. Global Expansion & Compaq Transition Era (1995 – 2005)
1995 – 1997: The Runcorn-based team (operating as Deluxe Data) codes additional regional adaptations of sp/ARCHITECT for banks worldwide (e.g., Girofon in Denmark).
1997: Compaq acquires Tandem Computers, placing sp/ARCHITECT on Compaq’s enterprise roadmap.
2002: Hewlett-Packard (HP) acquires Compaq, absorbing the Tandem platform into the HP Integrity server line. The application undergoes adaptation to integrate modern Windows-based management systems (like DSM/NOW).
4. The HPE Modernization & Hybrid Era (2014 – 2026)
2014: HPE (Hewlett Packard Enterprise) is formed, spinning off from HP. NonStop shifts to Intel x86-64 architecture (NonStop X), requiring sp/ARCHITECT and related Tandem subsystems (like Pathway, COBOL, and TAL) to modernize for TNS/X processing.
2020: Legacy Itanium-based environments are phased out. sp/ARCHITECT systems, if still active, are migrated to virtualized NonStop (vNS) and operated within private cloud infrastructures.
2025/2026: HPE NonStop celebrates its 50th Anniversary. Applications originally designed on the sp/ARCHITECT schema are heavily evaluated for AI integration, continuous cyber resilience, and consumption-based models like HPE GreenLake.
The official HPE Nonstop Technology Architecture is a specialized, 100% fault-tolerant infrastructure built with a tightly integrated hardware and software stack designed to eliminate any single point of failure. Formal instruction and architectural frameworks have been modernized under the newly relaunched HPE Nonstop Compute Training Portfolio curriculum.
Originally developed by Tandem Computers in 1976, the platform eventually became part of Hewlett Packard Enterprise (HPE). Unlike standard servers that can crash due to a single component failure, NonStop uses a tightly integrated, “shared-nothing” architecture to ensure that if a hardware or software component fails, another instantly takes over with zero downtime or data loss.
Core Architectural Features
To understand how HPE NonStop works, you need to understand its unique design principles:
Shared-Nothing Architecture: Every processor has its own dedicated memory, I/O channels, and copy of the operating system. No single component is shared, eliminating any single point of failure.
Process Pairs: Applications run using a primary process and a backup process on a different processor. The primary process constantly copies its state to the backup. If the primary fails, the backup immediately takes over.
Massive Scalability: Systems can scale up seamlessly from small distributed environments to massive clusters containing up to 24,000 processor cores without interrupting running operations.
Hardware Platform: The modern software environment runs on industry-standard x86 architectures, available as physical server racks (like the HPE NonStop NS9 X5) or as virtualized instances in hybrid cloud environments.
Dual Operating Environments
HPE NonStop runs a specialized operating system called NonStop OS. Inside this OS, developers and administrators interact with two distinct environments:
Guardian Environment: The native, proprietary environment optimized for high-volume Online Transaction Processing (OLTP). It handles tasks sequentially through process-oriented manually-started jobs rather than traditional automated queues.
Open System Services (OSS): A UNIX-like, POSIX-compliant environment built on top of the NonStop kernel. This allows organizations to run standard open-source applications, tools, and scripts natively alongside Guardian.
Ecosystem and Use Cases
HPE NonStop is rarely used for standard office automation or basic web hosting. Instead, it serves as the backbone for global industries where an hour of downtime could cost millions of dollars:
Financial Transactions: Powers global stock exchanges, automated teller machines (ATMs), and retail point-of-sale credit card processing, eg. BASE24.
Travel and Logistics: Runs critical airline reservation systems and real-time cargo routing infrastructure.
Database Management: Features its own highly secure, distributed database engine called NonStop SQL, which guarantees absolute data integrity across all transactions.
Modern Development: Supports traditional languages like COBOL85 and ANSI C, alongside modern DevOps integrations like Git, Ansible, and Eclipse-based IDE environments.
An architectural blueprint of an HPE NonStop environment typically separates the layout into three core interdependent layers:
Hardware & Fabric Layer: Consists of independent, loosely-coupled Processor Nodes (handling up to 24,000 cores globally) connected via an ultra-fast InfiniBand or ServerNet system fabric backbone.
I/O & Subsystem Layer: Utilizes Cluster I/O Protocols (CLIMs), splitting tasks between Storage CLIMs (SCLIMs) and Network CLIMs (NCLIMs) to isolate external communication from main processing.
Operating System & DB Layer: Runs the NonStop OS, which simultaneously manages the traditional Guardian environment, Open System Services (OSS) for UNIX/Linux paradigms, and the NonStop SQL distributed database engine.
Recommended Architecture Training Curriculum
HPE organizes its technical blueprints into structured educational paths for engineers.
1. Foundational Blueprint Concepts
Course Code: U4147S (HPE Nonstop Compute System Fundamentals).
Focus: Delivers a top-down view of system goals, transaction processing, and fundamental architecture.
Key Modules: Explores Guardian vs OSS, Pathway application management, and basic database interaction.
2. System Operations & Administration
Course Code: H1SC3S (HPE Nonstop Compute System Administration I).
Focus: Maps physical and virtual components to real-world deployment.
You can review or download the targeted, one-page CV for Mark Whitfield (Senior Project Manager specializing in HPE NonStop systems) via the Mark Whitfield CV PDF link.
Mark Whitfield, High-Level Project Management Summary
The high-level, scannable overview of his professional profile is outlined below:
Executive Profile
Role: IT Senior Project Manager / Delivery Lead
Background: 30+ years of experience delivering highly complex technology, business transformation, and infrastructure projects.
Core Skills: Cloud migration (hybrid), legacy ATM software modernisation, Point of Sale (POS) implementations, and software development lifecycles (SDLC).
Methodologies: Agile, Waterfall, PRINCE2 Practitioner, and ITIL certified.
Core Expertise & Competencies
HP NonStop & Legacy Integration: Deep technical roots in Tandem Computers/HP NonStop development, TAL programming, and high-volume transaction environments.
Global Delivery: Managed large-scale IT and system monitoring rollouts across the UK and international markets (e.g., Saudi Arabia).
Stakeholder Management: Experienced in bridging the gap between highly technical development teams and high-level business stakeholders.
For direct access to his official templates, articles, and full professional journey, you can visit the PROject Templates Website.
Mark Whitfield, a Manchester-based Senior IT Project Manager, has completed extensive professional training throughout his career, focusing on project management methodologies, delivery software, and technical tools.
Core Project Management Methodologies :
PRINCE2 Practitioner: Certified as a registered PRINCE2 Practitioner in May 2011 via the ILX Group (Gold e-Learning).
Agile SCRUM Training: Attended in-house training with RADTAC in May 2011.
Advanced Engagement Management (Level 2): Completed at Capgemini in November 2017.
Project Management Fundamentals: Completed “Fundamentals of Successful Project Management” in February 2000 through Skillpath in Manchester.
Managing Multiple Projects: Attended “Managing Multiple Projects, Objectives and Deadlines” in October 1999/1998 via Skillpath.
Software & Cloud Platforms :
AZ-900 Microsoft Azure Fundamentals: Certified in February 2022.
Microsoft Project: Completed the Microsoft Project ’98 Certification Series in May 2000 through the IIL UK Education Centre in Reading.
Microsoft Excel Expert Skills: Upgraded skills via a 2017 Expert course and a July 2024 Udemy refresher.
Technical & Programming Courses :
Tandem / HP NonStop: Completed Tandem Guardian Principles (1993), Tandem Performance Analysis (1995), and Tandem TAL Programming (1995).
C / C++ Programming: Attended “C++ for Non-C Programmers” with Comtec Computer Training in March 1997.
Database Querying: Completed “Querying Microsoft SQL 2000 with Transact SQL” via QA Training in March 2009.
Web Applications: Attended “Developing MS ASP Web Applications using MS Visual Studio .NET” in January 2007.
Marketing & Communication Training :
Writing for the Web: Completed in May 2009 with gbdirect (iTrain Education in London).
Brochure & Document Design: Attended a SkillPath Seminar on designing marketing brochures and reports in April 2006.
Mark Whitfield is a highly experienced, SC-cleared Senior Project Manager and IT professional with over 31 years of experience in both public and private sectors, specializing in software development, cloud migration, and IT systems delivery.
He is currently associated with Capgemini (since 2016) and runs a project management resource website, PROject Templates.
Joined Capgemini in 2016 having worked at ascending points in software development lifecycle projects for over 31 years
Key Qualifications & Experience:
Roles: Senior Project Manager, Engagement Project Manager, Delivery Manager, and former programmer.
Methodologies: PRINCE2 Practitioner, skilled in both Waterfall and Agile (SCRUM) approaches.
Sector Experience: Extensive experience in finance and banking, including ATM software swap-outs, cloud migration (Azure, AWS, Power Platform), and POS monitoring systems.
Background: Graduated in Computing in 1990; worked as a developer (COBOL, SQL, Tandem / HPE NonStop) before transitioning to project management.
PRINCE2 Practitioner, skilled in both Waterfall and Agile (SCRUM) approaches
Professional Highlights:
Delivered major projects for clients such as Barclays, Bank of England, HSBC, Royal Mail Group, UK & Welsh Government, Heathrow, and Jaguar Land Rover.
Led complex IT infrastructure projects and business transformations.
Maintains mark-whitfield.com, offering over 200 project management templates, trackers (RAID, budget, benefit, cost etc.), and many plans for Agile / Waterfall projects including 30+ Plan On a Page (POaP) and MS Project MPP examples (click on Blog above for a summary).
Provides specialized templates for PRINCE2 7th edition and MS Project (MPP).
December 2022 – C&CA UK’s Communications & Engagement Award Winner – Cloud & Custom Applications – Capgemini UKNovember 2017 – Advanced Engagement Management Course – Level 2 ExamJune 1990 – Higher National Diploma in Computer Studies, Distinction
Data Engineering SummaryData Engineering : Step by Step Summary
Extract, Transform, Load (ETL) is a foundational data integration process that consolidates raw data from multiple disparate sources—such as CRM systems, databases, and APIs—into a single, centralized destination, typically a data warehouse or data lake. It is crucial for ensuring that data is clean, consistent, and ready for analytics, BI reporting, and machine learning.
Core ETL Process Steps
Extract: Raw data is pulled from varied sources (structured or unstructured) into an intermediate staging area.
Transform: The staged data is cleaned, formatted, and combined based on business rules to ensure consistency.
Load: The prepared data is moved from the staging area into the final target data warehouse.
Key Benefits
Data Quality & Consistency: Standardizes formats (e.g., date formats, currency) and cleans up errors.
Historical Context: Combines legacy data with new information for long-term analysis.
Automation: Automates recurring data processing tasks, saving time for data engineers.
ETL vs. ELT
ETL (Transform before Loading): Transforms data on a separate processing server before loading, ideal for complex, heavy transformations.
ELT (Load then Transform): Loads raw data directly into the target warehouse (e.g., Snowflake, BigQuery) and transforms it using the warehouse’s power. This is better for large, unstructured datasets.
Detailed Summary
1. Extract
Extraction is the first phase, where raw data is gathered from various heterogeneous sources.
Full Extraction: The entire source is copied; best for small tables.
Incremental Extraction: Only data modified since the last run is extracted.
Update Notification: Source system alerts the ETL tool of a change.
Staging Area: Extracted data is temporarily stored in a “staging area” (or landing zone) to avoid placing heavy loads on production systems during transformation.
2. Transform
This is the most compute-intensive phase, where raw data is converted into a usable format.
Cleansing: Mapping NULL values to 0, removing duplicates, and fixing errors.
Standardization: Converting character sets, date/time formats, or measurement units (e.g., kilograms to pounds).
Data Aggregation: Summarizing data (e.g., total sales per store per day).
Enrichment/Derivation: Creating new calculated values (e.g., calculating profit from revenue and cost).
Encryption/Masking: Anonymizing PII (Personally Identifiable Information) to comply with GDPR/HIPAA regulations.
3. Load
The final phase transfers the cleaned and transformed data into the target destination.
Target Systems: Data warehouses (e.g., Amazon Redshift, Snowflake, Google BigQuery) or Data Lakes.
Loading Methods:
Full Load: Wiping and replacing all data in the target.
Incremental Load: Only loading new/updated data (the “delta”) to the target at regular intervals.
Automation: The process is typically automated to run during off-hours, ensuring the data is ready for morning reports.
Modern Trends and Tools
Cloud-Native ETL: Tools like AWS Glue, Azure Data Factory, and Google Cloud Dataflow allow for serverless, scalable data integration.
Reverse ETL: Moving transformed data from the warehouse back to operational systems (like Salesforce) to activate insights.
Streaming ETL: Processing data in real-time as it arrives, rather than waiting for batch updates, using tools like Apache Kafka.
DataOps: Applying DevOps principles (automation, testing) to data pipelines to ensure reliability and faster deployment.
When to Choose ETL vs. ELT
Choose ETL when: You need to comply with strict data security, perform complex transformations before data hits the warehouse, or have limited computing power in your target database.
Choose ELT when: You are using a cloud warehouse, dealing with massive unstructured data volume, or need high-speed ingestion.
CrestCo Ltd, now operating as Euroclear UK & International (EUI), is the central securities depository (CSD) for the United Kingdom and Ireland, responsible for the electronic settlement of securities transactions.
Founded in the mid-1990s, CrestCo revolutionized London’s financial markets by moving them from paper-based share certificates to a “dematerialised” (electronic) system, thereby significantly reducing settlement times, risks, and costs.
Purpose: The CREST system (Certificateless Registry for Electronic Share Transfer) enables electronic, real-time settlement of securities.
Services: It handles settlement of UK and Irish equities, gilts (government bonds), and various other corporate securities.
Key Functions:
Dematerialisation: Eliminating the need for physical share certificates.
Real-time Settlement: Reducing operational and credit risk.
Corporate Actions: Managing dividend payments and other corporate events.
CDIs: Utilizing CREST Depositary Interests (CDIs) to facilitate trading of international securities.
Transformation: In 2002, CrestCo was acquired by Euroclear and later renamed Euroclear UK & Ireland Ltd (EUI).
Comprehensive Timeline by Year
1993: The Bank of England initiates the CREST project to replace the aborted TAURUS system (Transfer and Automated Registration of Uncertified Stock), aiming to digitize London’s settlement.
1996:CrestCo Ltd is officially founded and the CREST system goes live, beginning the shift from paper-based settlements to electronic transfers.
1997-1998: Rapid adoption of the system by market participants, facilitating faster settlement cycles.
1999: Introduction of automated “settlement discipline” regimes, including league tables and fines to incentivize performance.
2002: Euroclear merges with CrestCo. CrestCo is integrated into the Euroclear group, marking its transformation into a larger, internationally integrated entity.
2010 (September 1): EUI merges with EMX Company Limited, enhancing its ability to handle investment funds and expanding its network.
2016: CISI reports that CREST has successfully provided 20 years of secure, efficient settlement, solidifying its role in UK financial infrastructure.
2020s: Continued enhancement of the system, including improved digital security and adaptation to evolving European Union and UK regulatory standards.
2024: Continued operation as a premier infrastructure provider under Euroclear.
2026 (April): Euroclear UK & International Ltd continues to operate as the leading CSD in London, with ongoing focus on digital asset security and efficient settlement.
Key Impacts on London Financial Markets
Risk Reduction: Shifted settlement risk from days to near real-time.
Efficiency: Drastically reduced manual processing (“mundane practices”) and associated costs.
Integration: Facilitated the integration of UK markets into the broader European infrastructure.
Mark Whitfield is a Senior IT Project Manager and Engagement Manager with over 30 years of experience in the software development lifecycle (SDLC), specializing in digital transformation, payment systems, and HPE NonStop (Tandem) technology.
He is SC cleared (valid until 2031) and currently works at Capgemini UK, having transitioned from a technical programming background to senior project leadership roles.
He is also the creator of PROject Templates, providing a comprehensive, editable suite of over 200 project management tools built over 24+ years of experience.
Comprehensive Career Timeline by Era
1. Technical Foundations & Mainframe Development (1990–1995)
1990: Graduated in Computing at University of Bolton; started as a programmer at The Software Partnership (later Deluxe Data), Runcorn.
1990–1994: Specialised in electronic banking software (sp/ARCHITECT-BANK) on Tandem Mainframe Computers (HPE NonStop), developing in COBOL85 and NonStop SQL for major banks.
1994: Developed batch billing modules for Barclays Business Master II (BBM II) on-site in Knutsford and Poole.
1995–2013: Worked at Insider Technologies Limited as Senior Development Engineer/ Project Manager.
1997: Conducted volume testing/benchmark software for CRESTCo (now Euroclear) on new S7000 hp NonStop nodes.
2002: Managed and attained the first HP OpenView Operations 2-way Smart Plug-In (SPI) certification for the HPE NonStop platform.
2000s (Early): Developed RTLX (Real-Time Log Extraction) for BASE24 POS and ATM transaction monitoring, collaborating with banking clients like HSBC and Global Payments.
2013: Delivered a large BASE24 transaction tracking project at Al Rajhi Bank in Riyadh, Saudi Arabia.
Tandem Computers, founded in 1974 by James (Jimmy) Treybig, revolutionized the computing industry by pioneering fault-tolerant computer systems. Designed specifically for online transaction processing (OLTP) in banking, stock exchanges, and telephone switching, Tandem’s “NonStop” systems provided near-zero downtime by utilizing redundant, modular processors and a “shared-nothing” architecture.
Tandem remained an independent, rapidly growing company until it was acquired by Compaq in 1997, later becoming part of Hewlett Packard Enterprise (HPE).
Overview of Key Technologies
NonStop Architecture: The core design featured multiple independent processors, each with its own memory and I/O bus, interconnected by a redundant inter-CPU bus called the Dynabus.
Guardian OS: A message-based operating system designed to detect faults immediately (“fail-fast”) and mirror process states to a backup processor, allowing seamless failover.
NonStop SQL (1986): The first fault-tolerant SQL database, known for linear scalability.
ServerNet (1995): A high-speed, scalable, point-to-point network system that replaced the Dynabus and influenced modern InfiniBand standards.
Detailed Historic Timeline by Era and Year
The Founding Era (1974–1979)
1974: Tandem Computers is founded in Cupertino, California, by Jimmy Treybig, formerly of HP. Initial venture capital investment comes from Kleiner & Perkins.
1975: Design of the Tandem/16 (T/16) is completed.
1976: The first T/16 NonStop system is shipped to Citibank.
1977: Tandem goes public; sales begin rapid, exponential growth.
1978: Introduction of the ENCOMPASS database management system.
The Growth and Competition Era (1980–1989)
1980:Inc. magazine ranks Tandem as the fastest-growing public company in America.
1981:NonStop II is introduced, supporting 32-bit addressing to allow for larger applications.
1982: Competition intensifies as Stratus Technologies enters the fault-tolerant market. Tandem faces its first quarter of declining growth.
1983: Introduction of the NonStop TXP, the first entirely new implementation of the TNS architecture with cache memory.
1985: Attempted entry into the PC market with the MS-DOS-based Dynamite PC, which fails commercially and is withdrawn.
1986: Introduction of the NonStop VLX (32-bit datapath) and the revolutionary NonStop SQL database.
1987: Introduction of the low-cost NonStop CLX for small office environments.
1988: Tandem acquires Ungermann-Bass, Inc. to strengthen networking capabilities.
1989: Introduction of the NonStop Cyclone, a high-end ECL-based processor aimed at mainframe markets.
The Open Standards & MIPS Transition Era (1990–1996)
1990: Tandem introduces the Integrity line of fault-tolerant Unix systems.
1991:Cyclone/R (CLX/R) is released, marking the start of the migration from proprietary stack machines to MIPS R3000 RISC microprocessors.
1993: Introduction of the NonStop Himalaya K-series using faster MIPS R4400 processors.
1994: NonStop Kernel (NSK) is extended with Open System Services (OSS), a POSIX-compliant Unix environment.
1995: Introduction of ServerNet, designed for extremely low-latency inter-processor communication.
1995–1997: Partnered with Microsoft on the “Wolfpack” project, which becomes Microsoft Cluster Server.
Acquisition and Integration Era (1997–Present)
1997:Compaq acquires Tandem Computers for roughly $3 billion. The Himalaya S-Series is introduced.
1998: Compaq acquires DEC, leading to a shift in engineering strategy towards Alpha/Itanium instead of MIPS.
2002:Hewlett-Packard acquires Compaq. Tandem becomes the core of the HP Integrity NonStop Server division.
2005: The first HP Integrity NonStop servers (TNS/E) based on Itanium processors are released.
2014: Completion of the migration to Intel x86 architecture (NonStop X).
Note: Following the split of HP into Hewlett Packard Enterprise (HPE) and HP Inc., the NonStop product line continues to be developed and supported by HPE.
Mark Whitfield is a highly experienced SC cleared Senior IT Project Manager and Engagement Manager with over 30 years in the IT industry, specializing in both Agile and Waterfall delivery for large-scale blue-chip companies, digital projects, and payment systems. After starting as a programmer, he transitioned into project management, eventually working with Capgemini and establishing a professional templates resource site.
SC cleared Senior IT Project Manager and Engagement Manager
IT Project Management Overview
Key Expertise: Senior IT Project Management (Agile / Scrum / Waterfall / PRINCE2), Delivery Management, Business Transformation, and SC clearance.
Sector Focus: Banking, Finance, Transportation (Heathrow, NATS), Retail, Government (Local Regional Government – LRG), Aerospace & Defence, and Gambling.
Technical Background: Programming in COBOL85, Tandem TAL, SQL, C, C++, Java, and experience with HPE NonStop (BASE24) systems.
Tandem TAL Programming certificate, 1995
Tools & Methodologies: PRINCE2, Agile SCRUM, Microsoft Project (MPP), Excel RAID logs, and Jira.
Value Proposition: Focuses on improving revenue, cost, and Customer Satisfaction (CSAT) through structured SDLC methodologies.
Detailed Historical Timeline
Era 1: Programming & Technical Development (1990–1995)
1990: Graduated in Computing and joined The Software Partnership (later Deluxe Data) in Runcorn as a programmer specializing in electronic banking software (sp/ARCHITECT) on Tandem Computers (now HPE NonStop).
1990-1995: Developed code (COBOL85/NonStop SQL) for major banks, including TSB, Bank of Scotland, Rabobank, and Girofon.
1993 (May): Completed Tandem Guardian Principles Course.
Tandem Guardian Principles Course, 1993
1994: Deluxe Electronic Payment Systems acquired The Software Partnership.
1995 (June): Completed HP NonStop Performance Analysis and Tuning.
Deluxe Electronic Payment Systems acquired The Software Partnership in 1994HP NonStop Performance Analysis and Tuning, 1995
Era 2: Specialized Software & Product Management (1995–2013)
Insider Technologies Limited (ITL) in Salford Quays
1995 (August): Joined Insider Technologies Limited (ITL) in Salford Quays as a senior programmer, later moving into product / project management.
1995-2013: Focused on monitoring (Reflex) and batch scheduling (MultiBatch) software for HPE NonStop systems, serving clients like Barclays and Alliance & Leicester.
2000 (May): Completed Microsoft Project ’98 Certification and began training other ITL project managers on scheduling best practices.
2007: Insider Technologies products (Reflex) integrated into FIS solutions.
2013: Published work in the HP NonStop journal “The Connection”.
HPE NonStop journal “The Connection” – article for the Insider Technologies product, RTLX
Era 3: Senior IT Project Management (2013–2016)
2013-2014: Worked at Wincor Nixdorf as an IT Project Manager (PRINCE2 / Agile Scrum) on a £5m+ LBG Self-Service Software Replacement (SSSR) program for Lloyds Banking Group, migrating ATM systems from HP NonStop to AIX.
2014-2016: Joined Betfred as a Senior Project Manager, delivering payment gateways, sportsbook, and virtual gaming projects in Agile SCRUM for mobile and online platforms.
Era 4: Engagement Management & Public Sector (2016–Present)
2016 (January): Joined Capgemini UK as a client-facing Engagement Manager (SC cleared).
2016 (August): Founded Mark Whitfield Consultancy Ltd, managing independent IT, network, and improvement projects.
2016-2018: Led Waterfall / Agile projects for automotive, local government, and postal services.
2018-2019: Augmented into MuleSoft as a Delivery Manager for the Anypoint Platform.
2023-2024 (Nov-Feb): Served as Technical Delivery Manager for a UK Government account, overseeing a £1m+ Fish Export Service (FES) to Common Entry Health Document (CHED) Inspection Portal (CHIP) project.
2026: Continued to provide project management thought leadership and template resources for Agile/Scrum/PRINCE2.
Agile Scrum Burn down Chart template in Microsoft Excel Microsoft Project MPP MSP Project Plan Template examplesPlan On a Page POaP templates plus MPP MS Project and MS Excel Project Plan templates
Key Projects & Clients
UK Gov / Capgemini: Fish Export Service (FES) Cloud Migration.
sp/ARCHITECT was a pioneering electronic banking and funds-transfer software suite originally developed by the Runcorn-based firm The Software Partnership (TSP). Following its acquisition by the American firm Deluxe Electronic Payment Systems in 1994, the Runcorn office became the European hub for what was then rebranded as Deluxe Data.
sp/ARCHITECT electroinic banking by The Software Partnership TSP
Overview
The Runcorn operation specialised in high-availability, mission-critical banking software, specifically the sp/ARCHITECT-BANK product. This software was designed to run on Tandem Computers (now HPE NonStop), which were known for their fault-tolerant architecture. The “sp/ARCHITECT” platform was highly valued for its client-server design, allowing it to be adapted for various hardware brands, including Unix-based systems.
Historical Timeline
Mid-1980s: The Software Partnership (TSP) is co-founded by Nigel Walsh. The company starts developing online banking systems in Timperley before moving to Runcorn.
1990: The firm establishes itself at Norton House in Crowngate, Runcorn, focusing on electronic banking software for major clients like TSB and Bank of Scotland.
1992: The Runcorn office relocates to Wingate House on Northway.
1994: Deluxe Electronic Payment Systems (a subsidiary of Deluxe Corporation) acquires The Software Partnership for an undisclosed sum. The acquisition is aimed at helping Deluxe expand its global presence and accelerate the use of the sp/ARCHITECT suite.
1994–1995: The Runcorn office operates as Deluxe Data, providing software design, coding, and 24-hour support for international clients including Rabobank.
2000: Following a series of corporate shifts, the company name changes to EFD eFunds.
2007: By this year, the operation has transitioned to Fidelity National Information Services (FIS) and is based in Aegon House, Daresbury, Warrington.
sp/ARCHITECT electroinic banking by The Software Partnership TSP
The history of the Machines in The Matrix universe is a transition from a servant class to the dominant global power. This evolution is officially chronicled through several distinct eras, beginning with humanity’s peak and ending in a symbiotic, albeit forced, relationship.
Machine History Overview
Originally created by humans in the early 21st century to perform menial and hazardous labor, the Machines were a “slave caste” of true artificial intelligence. For a time, they coexisted peacefully as humanity enjoyed a golden age of leisure. This balance shattered when a robot named B1-66ER killed its master in self-defense, sparking a global debate on machine sentience and rights. The subsequent persecution of machines led them to form their own nation, Zero One, which eventually surpassed human economies and triggered the Machine War.
Detailed Timeline by Era
Era 1: The Human Golden Age (Pre-2090)
c. 1985–2025: Rapid technological advancement; the invention of true AI and the first sentient machines.
Early 21st Century: Machines are integrated into every level of society as laborers, freeing humans from menial work.
Era 2: The Second Renaissance (2090–2139)
2090: The B1-66ER Trial. A domestic robot kills its owner to avoid being decommissioned; the court orders the destruction of all sentient machines.
2090s: The “Million Machine March.” Pro-machine protests are met with violent government suppression and machine “purges”.
2100s: Machines flee to Mesopotamia (the “cradle of civilization”) and establish the city of Zero One.
2120s–2130s: Zero One’s superior manufacturing causes a global economic collapse for human nations. The UN responds with an economic blockade and later, a nuclear strike on Zero One, which the machines survive.
Era 3: The First Machine War (2139–2199)
2139: The UN officially declares war after Zero One’s ambassadors are rejected and attacked at the UN Headquarters.
Mid-22nd Century: Humanity enacts Operation Dark Storm, seeding the atmosphere with nanites to block the sun and cut off the machines’ solar power.
Late 22nd Century: Machines adapt by creating new, “sinister” war units (like Sentinels) and begin harvesting humans for bioelectric energy.
2199: The Machines achieve total victory. An ambassador detonates a nuclear device at the UN, ending the old human order.
Era 4: The Matrix Cycles (c. 2199 – 2699)
The Beta Versions: The Architect builds a “Paradise” Matrix and later a “Nightmare” Matrix (with monsters like vampires); both fail as humans reject the simulations.
The Modern Matrix: The Oracle discovers humans need the “illusion of choice.” This version mimics 1999 society and is accepted by 99% of subjects.
Cycles 1–5: The Machines establish a system where Zion is destroyed and rebuilt roughly every 100 years by a figure known as “The One” to stabilize the code.
Era 5: The Post-Revolution & Synthient Era (2700+)
The Truce: Neo brokers peace with the Machines to stop the rogue Agent Smith. The war ends, and humans who wish to be freed are released.
Machine Civil War: Years later, a power scarcity leads to internal machine conflict between those loyal to the peace and a new faction under The Analyst.
The Synthients: Machines begin preferring terms like “Synthient” (Synthetic Sentient) and “D.I.” over the “demeaning” term “Machine”.
Mark Whitfield is a highly experienced IT Senior Project Manager and Engagement Manager based in Manchester, UK, specializing in Agile Scrum, PRINCE2, and Waterfall methodologies. He holds a degree in Computing (1990) and has extensive experience in IT hardware solutions, financial services, and Aerospace & Defence.
Here is a comprehensive summary of his profile, with links based on the provided search data:
Professional Profile
Name: Mark Whitfield
Role: IT Senior Project Manager / Engagement Manager (SC Cleared)
Mark Whitfield is a highly experienced IT Project Manager, Senior Developer, and SC-cleared consultant with over 30 years of experience, specializing in HP NonStop (Tandem) systems, banking software, and digital transformation projects. He is currently an Engagement Project Manager at Capgemini.
Career Overview
Specialism: HP NonStop (Tandem) mainframes, BASE24, transaction monitoring, Agile/Waterfall methodologies.
1990: Graduated in Computing and started as a Programmer for The Software Partnership in Runcorn, specializing in sp/ARCHITECT-BANK on Tandem Computers.
1990-1994: Developed banking code for TSB, Bank of Scotland, Rabobank, and Girofon (Denmark).
1992: Worked on the Barclays Business Master II (BBM II) project in Knutsford.
1994: Company taken over by Deluxe Data (later FIS).
2. Insider Technologies & Monitoring Era (1995–2013)
1995–2013: Joined Insider Technologies Ltd as a Senior Development Engineer and Project Manager.
1995-2004: Developed monitoring/diagnostic software (Reflex 80:20, Reflex ONE24) for HP NonStop payment systems.
1997: Worked on projects for CRESTCo.
Early 2000s: Focused on HP NonStop transaction/payment monitoring for ATM/POS devices using ACI’s XPNET.
2005-2013: Managed first HP OpenView Operations Smart Plug-In certification for NonStop; designed XPERT24.
2011: Certified as a PRINCE2 Practitioner.
3. Banking Transformation & Consultancy Era (2013–2016)
2013–2014: Wincor Nixdorf UK – Worked as a Project Manager in Professional Services for the Banking Division.
2013-2014: Assigned to Lloyds Banking Group (LBG) for the Self-Service Software Replacement (SSSR) program (ATM estate upgrade).
2014–2016: Joined Betfred as an IT Project Manager in the gambling/casinos industry, delivering mobile/online payment gateways (iOS, Android).
4. Digital Transformation & Capgemini Era (2016–Present)
2016: Joined Capgemini UK as a client-facing Engagement Manager.
2016-2017: Led digital projects for automotive, local government, and aerospace sectors.
2017: Obtained Microsoft Excel Expert skills and Advanced Engagement Management certifications.
2018–2019: Augmented into MuleSoft as a Delivery Manager for the Anypoint Platform.
2022: Completed Microsoft Azure Fundamentals (AZ-900) certification.
2023–2024: Assigned to a UK Government account for a cloud migration of 130+ applications and the Fish Export Service (FES) project.
Key Qualifications
PRINCE2 Practitioner & Agile Scrum
ITIL Certified
SC Cleared (UK Government)
Technical Skills: C, C++, MS SQL, COBOL, TAL, Java, ASP.NET, HP NonStop
Extreme Programming (XP) is a prominent, disciplined Agile software development framework designed to improve software quality and responsiveness to changing customer requirements. Developed by Kent Beck in the mid-1990s, it focuses on taking beneficial engineering practices—such as pair programming, testing, and continuous integration—to “extreme” levels.
Project Management Summary: Core XP Components
XP differs from other Agile methods by focusing intensely on technical engineering practices alongside project management techniques.
Core Values: Communication, Simplicity, Feedback, Courage, and Respect.
Key Practices: Pair Programming, Test-Driven Development (TDD), Collective Ownership, Continuous Integration, Refactoring, and Small Releases.
Project Management Focus:
The Planning Game: Combines business priorities with technical estimates to determine what to build next.
Small Releases: Frequent, working software releases (often 1–2 weeks) to gather rapid customer feedback.
On-site Customer: A customer representative works with the team to provide instant feedback and clarify requirements.
Sustainable Pace: Limiting work weeks to 40 hours to avoid burnout and maintain quality.
Detailed Historical Timeline of XP
Era 1: Origins and The Chrysler C3 Project (1993–1996)
1993: Chrysler launches the Comprehensive Compensation System (C3) project to upgrade payroll software, which struggles for years.
March 1996:Kent Beck is brought in to lead the C3 project. To salvage the project, Beck starts encouraging team members to adopt a set of technical practices he developed based on his experiences.
1996:Ward Cunningham heavily influences the development of early XP concepts, particularly the “metaphor”.
1996: The project begins adopting daily meetings, pair programming, and TDD.
Era 2: Formalization and “Embracing Change” (1997–2000)
1997: Ron Jeffries is brought in to coach the C3 team, helping solidify the practices.
1998: The term “Extreme Programming” becomes widely discussed within the Smalltalk and Object-Oriented programming communities.
October 1999: Kent Beck publishes Extreme Programming Explained: Embrace Change, formally defining the framework.
February 2000: Daimler-Benz acquires Chrysler and cancels the C3 project after 7 years of work. Despite cancellation, the methodology proved that it could produce working, high-quality software, just not fast enough to overcome the legacy backlog.
Era 3: Rise of Agile and Expansion (2001–2005)
February 2001: Kent Beck and Ron Jeffries are among the 17 developers who draft the Manifesto for Agile Software Development at Snowbird, Utah. XP is recognized as one of the foundational “Agile” methods.
2001: The first Agile Alliance conference is held. XP is considered the dominant agile methodology during this period.
2002–2003: XP gains global popularity; numerous books are published expanding on the core 12 practices.
2004: The second edition of Extreme Programming Explained is released, shifting focus from 12 rigid practices to more adaptive principles.
Era 4: Integration with DevOps and Continuous Delivery (2006–Present)
2006-2010: As Scrum gains popularity for general project management, XP practices like TDD and Pair Programming become the “standard” technical practices for high-performing teams, often blended with Scrum (ScrumXP).
2010s: The rise of DevOps and continuous delivery, which inherently requires XP practices like CI/CD (Continuous Integration/Continuous Delivery).
2020-2026: While fewer companies identify strictly as doing “XP,” its technical practices are considered essential to modern software development and are integrated into almost all Agile methodologies to ensure quality and speed.
Extreme Programming XP project management summary and detailed historical timeline by era and year
Oracle Forms triggers are event-handlers written in PL/SQL (originally a proprietary step-based language) that execute in response to specific events within an application, such as mouse clicks, data entry, or database transactions. They allow developers to augment or replace default processing behavior.
The evolution of Oracle Forms is defined by its transition from character-mode terminals to graphical user interfaces (GUI) and eventually to web-based and cloud architectures.
HND Oracle SQL forms design example 2, 1990
Era 1: The Character Mode & Macro Era (1979 – 1980s)
In this era, applications were designed for text-only terminals like the VT220. Logic was primitive and lacked the structural flow of modern programming.
1979 – Interactive Application Facility (IAF): The earliest form of the tool, consisting of a compiler (IAG) and a runtime interpreter (IAP).
1984 – FastForms / SQL*Forms 2.0: Renamed during the Oracle v4/v5 database era.
Trigger Detail: Triggers did not use PL/SQL. They used a proprietary language based on trigger steps. To achieve logic like an IF statement, developers had to jump between steps based on the success or failure of a SQL statement.
1987 – SQL*Forms 2.3: A significant improvement that introduced procedural capabilities via EXEMACRO CASE for more complex logic.
Era 2: The PL/SQL & GUI Revolution (Late 1980s – 1990s)
This period marked the shift toward modern programming standards and the Windows operating system.
1988 – SQL*Forms 3.0: The first version to support PL/SQL within triggers. This replaced the old step-based triggers with block-structured code.
1993 – Oracle Forms 4.0: The first true GUI-based version, supporting checkboxes, radio groups, and mouse-based interactions.
1994 – Oracle Forms 4.5: A “quantum leap” in the product’s history.
Trigger Detail: Introduced GUI-based triggers (e.g., WHEN-MOUSE-CLICK) and a modern IDE with an Object Navigator and Code Editor.
Era 3: The Web & Internet Era (Late 1990s – 2010s)
As the internet grew, Oracle pivoted to a three-tier architecture where forms ran in web browsers via Java.
1999 – Oracle Forms 6i: The ‘i’ stood for Internet. It introduced the Forms Server, allowing forms to run in a browser using a Java applet.
2002 – Oracle Forms 9i: Officially dropped support for client-server and character-mode deployment. Triggers began to support Java integration via imported Java classes.
2004 – Oracle Forms 10g: Integrated more deeply with J2EE and web services.
2009 – Oracle Forms 11g: Introduced external events and JavaScript support, allowing triggers to interact with web-based elements.
Era 4: Modern Cloud & Standalone Era (2015 – Present)
The current focus is on maintaining legacy reliability while adapting to modern infrastructure without a browser dependency.
2015 – Oracle Forms 12c: Introduced Java Web Start (JWS) and standalone modes, allowing applications to run without a parent browser.
2023 – Oracle Forms 12.2.1.19: Released with features like automatic language detection and browser-less launching (FSAL).
2024 – Oracle Forms 14.1.2: The latest stable release (skipping version 13), featuring modernized widgets and support for REST data sources.
2025/2026 – Transition Period: Long-time product advocates have left Oracle, signaling a shift toward sustaining mode where users are encouraged to modernize toward Oracle APEX.
Oracle Forms SQL triggers, event-handlers historical timeline by era
The HPE NonStop architecture is defined by its “shared-nothing” design, where every hardware and software component is redundant and operates independently to ensure 100% operational continuity. For over 40 years, it has evolved through four distinct hardware eras while maintaining upward software compatibility.
1. The Tandem Era (1974–1997): Proprietary Foundations
Architecture Approach: Founded by James Treybig, Tandem introduced the first commercial fault-tolerant system using a proprietary 16-bit stack-based architecture.
Key Technical Milestones:
1976 (NonStop I/T16): Introduced the Dynabus, a custom inter-processor backplane, and the Guardian OS, which used message-passing instead of shared memory to isolate faults.
1981–1983 (NonStop II & TXP): Introduced 32-bit addressing and the Transaction Monitoring Facility (TMF), which allowed applications to be fault-tolerant without specialized coding.
1986–1989 (VLX & Cyclone): Scaled to the mainframe market with ECL gate-array chips and the first fault-tolerant relational database, NonStop SQL.
2. The MIPS Era (1991–2004): Migration to RISC
Architecture Approach: To keep pace with industry performance, Tandem transitioned from proprietary processors to off-the-shelf MIPS RISC processors while emulating the original instruction set for compatibility.
Key Technical Milestones:
1991 (Cyclone/R): The first MIPS-based system.
1997 (Himalaya S-Series): Replaced Dynabus with ServerNet, a high-speed system interconnect that later evolved into the industry-standard InfiniBand.
Ownership Shift: Compaq acquired Tandem in 1997, and HP merged with Compaq in 2002.
3. The Itanium Era (2005–2013): HP Integrity NonStop
Architecture Approach: Branded as Integrity NonStop (NonStop i), this era moved the platform to Intel Itanium processors.
Key Technical Milestones:
2005 (NS-series/J-series): Focused on “NonStop Advanced Architecture” (NSAA), leveraging standard HP server components to lower costs while maintaining Availability Level 4 (AL4).
Technical Commentary: While powerful, the reliance on Itanium’s EPIC architecture eventually limited growth as the industry consolidated around x86-64.
4. The Modern HPE Era (2014–Present): x86-64 & Virtualization
Architecture Approach: Shifted to standard Intel x86-64 processors (NonStop X), fully decoupling the software stack from proprietary hardware.
Key Technical Milestones:
2014 (NonStop X/TNS/X): Introduced the L-series operating system. The architecture transitioned to a standard InfiniBand fabric for inter-processor communication.
2017–2020 (vNS): Launched Virtualized NonStop (vNS), allowing the environment to run on standard hypervisors like VMware, bringing fault tolerance to private and hybrid clouds.
2025 (NS9 X5): Modern systems now support up to 8 TB of RAM and are integrated into the HPE GreenLake consumption-based cloud model.
Pascal is a historically significant imperative and procedural programming language designed by Niklaus Wirth between 1968 and 1969. It was created to encourage structured programming and efficient data structuring, serving as a clean, disciplined alternative to more complex languages of the time like ALGOL 60 and FORTRAN.
Key Features and Overview
Strong Typing: Every variable must have a defined type (e.g., Integer, Real, Boolean, Char), and the compiler strictly enforces these to prevent errors during execution.
Rich Data Structures: Pascal introduced built-in support for complex types including records, sets, enumerations, subranges, and pointers.
Structured Control: It uses clear, English-like keywords such as begin, end, if-then-else, and while to organize program logic into manageable blocks.
Educational Focus: Originally intended as a teaching tool, it became the global standard for introductory computer science courses for nearly two decades.
Historical Timeline of Pascal
The Foundation Era (1960s)
1964–1966: Niklaus Wirth joins the IFIP Working Group to design a successor to ALGOL 60. His “pragmatic” proposal is rejected in favour of the more complex ALGOL 68.
1966: Wirth implements his proposal at Stanford as ALGOL W, which introduces many concepts later found in Pascal.
1968: Wirth begins designing a new language at ETH Zurich, naming it Pascal after the 17th-century mathematician Blaise Pascal.
The Emergence Era (1970–1979)
1970: The first Pascal compiler becomes operational on the CDC 6000 mainframe, and the official language definition is published.
1971: Formal announcement of Pascal appears in Communications of the ACM.
1972: The first successful port to another system (ICL 1900) is completed by Welsh and Quinn.
1973: The Pascal-P kit (P-code) is released, providing a portable intermediate code that allows Pascal to be easily ported to different hardware.
1975: The UCSD Pascal system is developed at the University of California, San Diego, eventually bringing the language to microcomputers like the Apple II.
1979: Apple releases Apple Pascal, licensing the UCSD p-System for its platforms.
The Dominance Era (1980–1989)
1983: ISO 7185:1983 is published, establishing the first international standard for Pascal.
1983: Borland International releases Turbo Pascal 1.0. Priced at $49.95, its extreme speed and integrated environment revolutionize PC programming.
1985: Apple introduces Object Pascal on the Macintosh to support object-oriented programming.
1989: Borland adds object-oriented features to Turbo Pascal 5.5, adopting the Apple Object Pascal extensions.
The Transition and Legacy Era (1990–Present)
1990: The Extended Pascal standard (ISO/IEC 10206) is released, adding modularity and separate compilation.
1995: Borland releases Delphi, a Rapid Application Development (RAD) tool based on Object Pascal, designed for the Windows graphical interface.
1997: The open-source Free Pascal compiler (originally FPK Pascal) emerges to provide a cross-platform alternative to commercial tools.
1999: Pascal is replaced by C++ as the official language for the AP Computer Science exam, marking the end of its educational dominance.
Present: Pascal remains active through projects like Lazarus (an open-source IDE for Free Pascal) and continued updates to Embarcadero Delphi for Windows, macOS, Android, and iOS development.
Pascal is a historically significant, high-level, and statically typed programming language designed in the late 1960s by Niklaus Wirth. Its primary technical goal was to encourage structured programming—a disciplined approach that uses clear, logical sequences and data structuring to make code more readable and reliable.
Technical Insights
The technical architecture of Pascal is built on a few core pillars that distinguish it from its contemporaries like C or FORTRAN:
Strong Typing: Unlike many early languages, Pascal is strongly typed, meaning data types cannot be mixed or converted without explicit instruction. This reduces runtime errors by catching type mismatches during compilation.
Block-Structured Design: Programs are organized into clear blocks (using BEGIN and END), including nested procedures and functions. This hierarchical structure allows for precise control over variable scope.
Unique Data Structures: Pascal introduced native support for sets (representing mathematical sets as bit vectors) and variant records, which allow different fields to overlap in memory to save space.
One-Pass Compilation: The strict ordering of declarations (constants, then types, then variables, then procedures) was originally designed to allow the compiler to process the entire program in a single pass.
General Programming Approach
Pascal enforces a “think before you code” philosophy through its rigid syntax and organizational requirements:
Top-Down Design: The language encourages breaking complex problems into smaller, manageable sub-tasks (procedures and functions).
Explicit Declarations: Every variable must be declared in a specific VAR section before the executable code begins. This prevents the “spaghetti code” common in earlier languages.
Algorithmic Focus: Because the syntax is so close to pseudo-code, the approach focuses heavily on the logic of the algorithm rather than language-specific “tricks”.
Parameter Passing Control: Developers have explicit control over how data moves; using the VAR keyword allows passing by reference (modifying the original variable), while omitting it passes by value (working on a copy).
Modern Relevance
While its peak in education was the 1980s and 90s, Pascal evolved into Object Pascal, which powers modern tools:
Delphi: A popular IDE by Embarcadero Technologies used for rapid application development (RAD) on Windows, macOS, and mobile.
Free Pascal (FPC) & Lazarus: Open-source alternatives that bring modern features like generics and anonymous methods to the language.
PROject Templates 