We source, vet, and manage hiring so you can meet qualified candidates in days, not months. Strong English, U.S. time zone overlap, and compliant hiring built in.
.svg){kind=logo}
REXX is a procedural scripting and batch processing language primarily used in IBM mainframe and midrange systems. If your organization relies on z/OS, i5/OS, or other legacy IBM platforms for core business processes, REXX developers are essential for automating workflows, writing JCL-adjacent scripts, and maintaining critical batch jobs that process millions of transactions daily. South connects you with experienced REXX specialists from Latin America who understand mainframe operations and can modernize legacy systems while maintaining stability.
REXX (Restructured Extended Executor) is a procedural scripting language developed by IBM in the 1980s, designed for ease of use while maintaining power for systems programming and automation tasks. Unlike compiled languages, REXX is interpreted and dynamically typed, making it ideal for writing batch jobs, command scripts, and system utilities on mainframe, midrange, and desktop environments. It's primarily associated with IBM z/OS (mainframe), IBM i (formerly i5/OS and AS/400), and TSO/ISPF environments where it remains deeply embedded in operational workflows.
REXX occupies a unique niche in enterprise infrastructure. While newer languages have emerged, REXX continues to power mission-critical batch processes in financial services, insurance, telecommunications, and government sectors where mainframe systems remain the backbone of operations. The language is known for its readability, straightforward syntax, and powerful string handling capabilities, features that made it attractive in the 1980s and still matter today when you're writing 500-line batch scripts that process overnight data loads.
Modern enterprises increasingly view REXX through a modernization lens: as a bridge technology. Teams use REXX to wrap legacy systems, create interfaces between mainframe and cloud infrastructure, or maintain operational stability while gradually migrating to cloud-native architectures. A REXX developer with modern systems knowledge (REST APIs, cloud platforms, containerization) becomes invaluable in hybrid IT scenarios.
You need REXX expertise in several specific scenarios. The most common: you operate mainframe or midrange systems and need someone to write, maintain, or optimize batch processing logic. This includes JCL coordination, dataset manipulation, system automation, and operational scripts. REXX is the dominant language for this work in IBM z/OS and i5/OS environments.
The second major use case is modernization and system integration. If you're building APIs to expose mainframe data, creating microservices that call z/OS systems, or integrating your legacy platforms with cloud services, a REXX developer with API knowledge can architect the bridge layer. They understand both the constraints of mainframe systems and the requirements of modern architectures.
You should also consider REXX talent when you're facing a skills gap in your mainframe operations team. The REXX community is aging, and finding expertise in your local market is increasingly difficult. A remote REXX developer from Latin America can fill critical gaps while you build internal expertise through knowledge transfer and mentoring.
REXX is NOT the right choice for building new greenfield applications, cloud-native systems, or mobile applications. It's also not suitable for compute-intensive data science or real-time systems where performance-critical compiled languages are necessary. Similarly, if your organization is planning to fully exit mainframe within 5 years, investing heavily in new REXX expertise may not align with your roadmap. Instead, focus on REXX knowledge transfer and selective modernization.
Team composition matters when hiring REXX developers. Pair them with systems engineers who understand your infrastructure, database architects (REXX often interacts with DB2 and VSAM datasets), and ideally a cloud architect if you're building integration layers. REXX developers should also have basic networking knowledge for understanding how batch jobs interact with system resources.
When evaluating REXX candidates, the core skill is fluency in the language itself: variables, control structures, parsing, string handling, and function calls. Beyond syntax, look for demonstrated experience with REXX in production environments, particularly batch job design, error handling, and performance optimization. Many REXX developers have 10+ years in the language, so experience depth is typically a strength in this market.
The key differentiator is systems knowledge. A strong REXX developer understands how their scripts interact with the broader mainframe: dataset organization (DSORG, record formats), JCL job submission and scheduling, TSO/ISPF concepts, and ideally some DB2 SQL or VSAM knowledge. They've debugged real batch jobs under production pressure and understand concepts like job dependencies, error recovery, and log parsing.
Modern REXX developers are increasingly evaluated on systems integration skills. Can they write REXX that calls REST APIs or interacts with cloud platforms? Do they understand containerization? Have they worked with configuration management tools to deploy REXX scripts? These skills signal someone who can bridge legacy and modern systems.
Red flags to watch for: candidates who have only academic REXX experience with no real batch processing exposure, those who cannot articulate how their code handles errors or resource constraints, and anyone who treats REXX purely as a legacy maintenance language without understanding modernization opportunities. Also watch for engineers who lack any exposure to systems thinking or infrastructure concepts.
Junior (1-2 years): Understands REXX syntax, has written simple batch scripts, familiar with basic dataset operations and simple JCL coordination. Can write functional code under guidance but may not optimize performance or handle edge cases gracefully. Needs mentoring on production best practices.
Mid-level (3-5 years): Writes production batch jobs independently, understands performance implications of code choices, can debug complex scripts, familiar with DB2 integration and error handling patterns. Knows systems fundamentals and can communicate with infrastructure teams. Contributes to architecture discussions around system integration.
Senior (5+ years): Designs batch systems, mentors junior developers, understands modernization strategies and can architect interfaces between legacy and cloud systems. May have deep expertise in specialized areas (high-volume data processing, real-time batch acceleration, mainframe security). Often serves as a bridge between legacy operations and modern development practices.
Walk me through the most complex batch processing system you've designed in REXX. What were the key design decisions? A strong answer shows understanding of job dependencies, error handling, performance optimization, and how the batch system fit into broader business processes. Listen for specific examples: dataset names, scheduling considerations, failure recovery logic. Someone who can explain WHY they made certain architectural choices understands systems thinking.
Tell me about a time you optimized a slow-running batch job. What was the bottleneck and how did you fix it? This tests real production experience. Strong candidates discuss specific optimization techniques: reducing I/O, improving algorithm efficiency, leveraging mainframe-specific features (parallel processing, hardware acceleration), or redesigning data flow. They'll mention measurement and validation, not guessing.
How do you approach debugging a REXX script that fails intermittently in production? Strong answers discuss systematic troubleshooting: checking logs, isolating variables, understanding timing issues, verifying dataset states. They discuss how they communicate findings to operations teams and implement fixes without disrupting running jobs.
Describe your experience integrating REXX systems with modern platforms (APIs, microservices, cloud systems). This separates legacy-only specialists from modernization-capable developers. Good answers show concrete examples: REST API calls from REXX, JSON parsing, cloud credential management, or event-driven batch triggers. Indicates awareness that REXX systems don't exist in isolation.
What's your experience with REXX performance analysis and tuning? Strong candidates understand CPU vs I/O bottlenecks, know how to read SMF records or performance monitoring tools, and can explain trade-offs between code simplicity and performance. They've made decisions about when to optimize and when to accept reasonable performance.
Write a REXX snippet that reads a sequential dataset, counts occurrences of a pattern, and writes results to an output dataset. Include error handling. Evaluate for: correct REXX syntax (OPENFILE, DO WHILE, PARSE statements), dataset handling, pattern matching logic, error trapping, and code clarity. A junior developer might miss error handling; a senior developer writes defensive code that handles missing datasets, read errors, and validates output.
How would you optimize this REXX loop for performance? [Show a naive implementation that processes large datasets] Strong developers discuss specific techniques: reducing I/O calls, using proper stemmed arrays instead of repeated parsing, avoiding unnecessary dataset opens, leveraging REXX built-in functions. They explain why each optimization matters on mainframe systems where CPU and I/O resources are carefully metered.
Explain the difference between EXTERNAL, GLOBAL, and local variables in REXX. When would you use each? This tests scope understanding and API knowledge. Correct answer shows understanding of variable lifetime, how variables pass between procedures, and appropriate design patterns. A good answer includes a practical example (sharing state across subroutines vs isolated functions).
How would you handle this scenario: A REXX batch job needs to process CSV data from a cloud service and write results back to a mainframe dataset. What are the key considerations? Strong answers discuss: API authentication (credentials storage), network timeouts and retry logic, data format conversion (CSV to EBCDIC if needed), error handling for API failures, and logging. They think about both the technical integration and operational concerns (how do you monitor this job?).
A REXX script processes 10 million records and is taking too long. Walk me through your diagnostic approach. Evaluate for systematic thinking: understanding the current runtime, profiling to find hot spots (parsing? I/O?), proposing specific improvements, and validating changes don't break functionality. A strong answer shows they've done this before and has a methodology.
Build a REXX batch job that reads an input dataset containing employee records (fixed-format, 100-byte records), filters for employees in a specific department, calculates average salary, and writes summary statistics to an output dataset. Include error handling for missing input, malformed records, and dataset access issues. Expected time: 90 minutes. Evaluation criteria: correct REXX syntax, proper dataset handling, clear error handling, readable code with comments, and working output. Senior candidates should optimize for large dataset sizes and discuss performance implications.
Latin America REXX Developer Rates (2026):
US Market Rates (for comparison):
REXX is one of the few skill areas where Latin American rates represent 40-55% savings compared to equivalent US talent, making remote REXX developers a strong financial decision. The talent pool in Argentina, Brazil, and Colombia remains stable and experienced. Argentina has particularly deep REXX expertise due to historical banking and fintech presence.
When budgeting, remember that REXX developers are often integral to critical infrastructure; reliability and knowledge transfer matter more than hourly cost. A mid-level LatAm REXX developer is often more reliable than a junior US developer, and costs 30-40% less. Many organizations hire senior LatAm REXX developers as knowledge transfer partners specifically to reduce the risk of losing expertise.
Latin America hosts a mature REXX ecosystem, particularly in Brazil, Argentina, and Colombia, with decades-long traditions in mainframe operations and systems programming. These countries developed strong IBM systems expertise through banking and government sectors, creating a stable talent pool of experienced developers who understand not just REXX syntax but the full operational context in which it runs.
Time zone overlap is significant. Most LatAm REXX developers work UTC-3 to UTC-5 (Brazil, Argentina, Colombia), providing 6-8 hours of real-time collaboration with US East Coast teams. This matters for REXX projects because batch job failures often require synchronous debugging and immediate attention. Having someone in an overlapping time zone who can review logs and implement fixes quickly is operationally valuable.
REXX developers from Latin America typically bring systems thinking that's increasingly rare in other markets. They've worked in environments where infrastructure, operations, and application code are deeply integrated, and they understand the constraints and possibilities of mainframe systems. This translates to better code, fewer production issues, and fewer "I didn't think about that" moments during integration.
English proficiency in the LatAm technical talent pool is strong. REXX developers have often worked on distributed teams and understand documentation, code comments, and technical communication. Remote collaboration with REXX developers from Argentina, Brazil, or Colombia is typically seamless from a communication perspective.
Hiring a REXX developer through South starts with understanding your specific needs. Are you building a new batch processing system, modernizing legacy code, or filling a gap in your operations team? We ask detailed questions about your infrastructure, your batch processing patterns, and the integration points REXX will touch. This specificity matters because a developer great at batch automation might not be the right fit if your primary need is mainframe-to-cloud integration.
We then match you from our pre-vetted network of REXX specialists across Latin America. Our vetting process includes technical assessment of REXX fundamentals, systems knowledge, and typically a project scenario that mirrors your actual needs. For REXX specifically, we validate batch processing experience and infrastructure familiarity because these are non-negotiable for production work.
You conduct interviews with matched candidates, typically focusing on your specific architecture and integration needs. We facilitate the process and provide guidance based on our experience with hundreds of REXX placements. Once you select a candidate, we handle onboarding, documentation, and ensure a smooth transition into your team.
Throughout the engagement, South provides ongoing support. If a matched developer isn't meeting expectations after 30 days, we replace them at no additional cost, with no questions asked. This guarantee protects you and ensures we're motivated to make the right match from day one. For REXX specifically, where expertise is precious and availability is limited, this guarantee is significant.
Ready to add experienced REXX talent to your team? Start a conversation with South today and let's discuss your mainframe modernization and batch processing needs.
REXX powers batch processing, system administration, and operational automation on IBM mainframes (z/OS) and midrange systems (IBM i). It's used for ETL processes, dataset manipulation, job scheduling, system utilities, and bridging between legacy systems and modern platforms. While not used for new application development, REXX remains critical infrastructure for organizations with IBM systems.
No. REXX is appropriate for maintaining and optimizing existing batch systems, automation, and system integration layers. For new application development, choose languages suited to your target platform: cloud-native applications use Python, Node.js, or Go; web applications use JavaScript/TypeScript; modern enterprise systems use Java or .NET. REXX should be part of your infrastructure, not your core business logic.
REXX if you're writing mainframe-specific batch jobs and system utilities where REXX is the native language. Python if you want to integrate mainframe systems with cloud platforms or build tools that work across your infrastructure. In practice, many organizations use both: REXX for core batch logic, Python for integration layers and automation that spans systems.
Mid-level REXX developers in Latin America range from $42,000-$60,000/year, while senior developers cost $65,000-$90,000/year. This represents 40-55% savings compared to equivalent US talent. Pricing varies by country; Argentina and parts of Brazil are at the higher end due to deeper talent pools and cost of living.
From first conversation to a matched candidate ready for interviews: typically 5-10 business days. Interview and selection: 1-2 weeks. Onboarding and project start: 1-2 weeks after selection. Total time from request to productive developer on your team: 3-4 weeks in most cases.
For maintaining existing batch systems and bug fixes, mid-level developers are sufficient. For designing new batch architectures, optimizing performance, or building integration layers, senior developers are worth the investment. Staff-level REXX developers are valuable if you lack internal mainframe expertise and need someone who can also mentor your team and architect modernization strategies.
Yes. South places developers on part-time and project-based engagements. For short-term work (under 3 months), communicate that clearly in your initial request so we can match someone available for that duration. Part-time REXX developers are common, especially for organizations that need occasional optimization or maintenance support.
Most South REXX developers operate in UTC-3 to UTC-5 (Brazil, Argentina, Colombia), providing 6-8 hours of real-time overlap with US East Coast teams. This overlap is valuable for REXX because batch job failures often require synchronous troubleshooting. We can accommodate requests for specific time zones if needed.
Our vetting includes technical assessment of REXX fundamentals (syntax, control structures, string handling), systems knowledge (JCL, datasets, DB2), and real-world problem-solving in batch processing scenarios. For senior candidates, we assess their ability to design systems, mentor others, and bridge legacy and modern infrastructure. References from previous clients are always verified.
We replace them at no additional cost within the first 30 days of engagement. If expectations aren't being met, communication issues arise, or the skill fit is off, we match you with a different candidate immediately. This 30-day guarantee is our commitment to making the right match.
Yes. South handles all payroll, tax compliance, and benefits administration for your REXX developers in their respective countries (Brazil, Argentina, Colombia, etc.). You pay South one all-in rate; we manage all local compliance. If you prefer a direct hire relationship, we can facilitate that conversation as well.
Absolutely. Whether you need a team of batch processing specialists, a mix of junior and senior developers for knowledge transfer, or a full systems engineering group, South can assemble the right team for your mainframe modernization goals. We've placed teams as large as 10+ developers. Let's discuss your specific needs.
