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}
NATURAL is a legacy programming language designed for rapid development of business applications, particularly on mainframe systems. Created in the 1970s and still widely used in banking, insurance, and large enterprises, NATURAL emphasizes readability through English-like syntax. Unlike COBOL or assembly, NATURAL abstracts away low-level complexity while remaining close to the business domain. For organizations maintaining critical legacy systems, NATURAL expertise is essential but increasingly scarce.
NATURAL is a business-oriented programming language designed for mainframe and enterprise application development. It emphasizes English-like syntax (PERFORM, MOVE, COMPUTE, IF, REPEAT) that makes programs readable even to non-programmers. NATURAL applications typically run on IBM mainframes or Unix/Linux systems with the Natural runtime. It's particularly strong for data manipulation and reporting, reflecting its origins in the era when business data processing was the primary computing workload.
NATURAL was developed by Software AG in the 1970s as part of the Natural application development system. The language remains popular in large enterprises, particularly in financial services and insurance, where existing NATURAL codebases are critical to operations. New development in NATURAL is rare in modern organizations, but maintenance and modernization of legacy systems is a constant demand.
Key characteristics: NATURAL is procedural and statically typed. Programs are organized into modules with clear data definitions and structured control flow. The language integrates tightly with databases (particularly ADABAS, Software AG's database), reducing boilerplate. Performance is strong for business logic and reporting because the language and runtime are optimized for those workloads.
The NATURAL ecosystem is shrinking but stable. New NATURAL code is rare; maintenance and legacy system modernization dominate hiring. IBM and Software AG continue to support the language, and enterprises are investing in gradual migration paths (wrapping NATURAL code with modern APIs, modernizing the business logic layer) rather than big rewrites. This means NATURAL developers are increasingly valuable because supply is falling while demand remains.
Hire a NATURAL developer when you have legacy mainframe systems written in NATURAL that require maintenance, debugging, or features. Common scenarios: maintaining banking systems, insurance platforms, or large ERP deployments; adding features to legacy NATURAL applications; fixing bugs in production systems; or modernizing NATURAL code to expose via APIs to modern applications.
NATURAL is not suitable for new development. Modern languages and frameworks are better for new business applications. However, for organizations with billions of dollars in NATURAL-based production systems, hiring NATURAL developers is not optional.
Ideal team composition: pair NATURAL developers with modernization architects who understand how to gradually expose legacy NATURAL logic via APIs or replace it with modern services. Business analysts who understand the original business logic are also critical. DevOps engineers familiar with mainframe deployment and monitoring are valuable.
The talent supply is tight. NATURAL developers are aging out, and fewer young developers are learning the language. This creates both urgency and opportunity. Hiring a strong NATURAL developer now locks in knowledge that's increasingly hard to find. South sources from a global network and can often find developers faster than direct hiring.
Typical project timelines: maintenance is steady-state; feature development is slower because developers must understand existing architecture. Modernization projects are lengthy but necessary for long-term sustainability.
A strong NATURAL hire needs: (1) deep NATURAL language expertise (modules, data definitions, control flow), (2) understanding of mainframe or enterprise systems, and (3) shipping experience in production NATURAL environments. Red flags: developers with only COBOL background who claim easy NATURAL transition, or developers who haven't maintained production systems.
Look for developers with experience in specific NATURAL domains: banking, insurance, or large-scale data processing. They should understand both the technical language and the business context of the systems they've maintained. Developers who have worked on ADABAS or other Natural-integrated databases are ideal.
Mid-level (5-10 years NATURAL): Has maintained production NATURAL systems, understands module architecture and data definitions, can debug and add features. Knowledgeable about ADABAS or other databases. Likely coming from financial or insurance sector.
Senior (10+ years NATURAL): Has architected large NATURAL systems, mentored juniors, and guided modernization efforts. Understands both legacy constraints and modern patterns. Can lead teams or provide consulting on legacy system strategy.
Soft skills: patience with legacy systems and business context. NATURAL systems are typically stable and boring, which is the point. You need developers who appreciate that and can work methodically without chasing flashy tech trends.
1. Tell us about a complex NATURAL program you've maintained or enhanced. What was the business logic, and what was challenging about the code? Listen for understanding of NATURAL module structure and ability to navigate legacy code. Strong answer shows they've shipped enhancements and understand business context.
2. You're tasked with exposing a legacy NATURAL system via a REST API for modern applications. Walk us through your approach.** Good answer: understand what NATURAL can and cannot do natively, plan for a service layer (wrapper), test carefully. Excellent answer discusses phased migration and maintaining backward compatibility.
3. Describe your experience with ADABAS or another database integrated with NATURAL. What queries have you optimized, and how? Should show database query optimization experience. Strong answer includes understanding of database locking, performance profiling, and avoiding N+1 query patterns.
4. Tell us about a time you debugged a production NATURAL issue. What tools did you use, and how did you ensure the fix was safe? Listen for methodical debugging approach, use of NATURAL debugging tools, testing rigor. Strong answer includes rollback planning.
5. How do you approach modernizing a legacy NATURAL system? What's your strategy for gradual migration without breaking existing functionality? Should discuss: API wrapping, strangler pattern, testing, rollback. Strong answer shows thinking about business continuity and risk management.
1. Explain the difference between local data areas (LDAs) and global data areas (GDAs) in NATURAL. When would you use each? Should show deep understanding of NATURAL's data scoping model. Good answer includes performance and maintainability considerations.
2. Write a NATURAL program that reads records from a database, applies business logic, and outputs results to a report file. Include error handling.** Evaluate: NATURAL syntax correctness, loop structure, error handling, data definitions. Strong answer shows clean, maintainable code and considers edge cases.
3. Describe NATURAL's PERFORM statement and how it differs from subroutines in modern languages. What are the implications? Should understand NATURAL's procedural model and how it maps (or doesn't) to modern patterns. Good answer discusses call stacks and state management.
4. How would you approach refactoring a large, monolithic NATURAL program into smaller, reusable modules? Should discuss: module boundaries, data passing, testing, avoiding circular dependencies. Great answer includes strategies for maintaining backward compatibility.
5. You discover a NATURAL program with a subtle bug that only manifests under specific database conditions. How would you debug it? Should mention database profiling tools, NATURAL debugging, and logging strategies. Strong answer shows patience with complex systems and methodical approach.
Take-home exercise (4-6 hours): Given a legacy NATURAL program with documented business logic, add a feature and fix a subtle bug. Requirements: maintain code style, add appropriate error handling, provide test cases. Evaluate on: NATURAL syntax correctness, code maintainability, understanding of original logic, testing rigor. Scoring: correct implementation with good testing gets full marks; working code with minimal test coverage gets 70%; incomplete or incorrect code gets 30%.
NATURAL expertise commands premium rates due to scarcity and criticality. Developers are hard to find and even harder to replace, making retention essential.
LatAm NATURAL Developer Salary (2026):
Comparison to US Rates:
LatAm rates are 30-40% lower than equivalent US salaries. A LatAm senior NATURAL developer at $170K is equivalent to a US hire at $240K-280K. The scarcity premium is significant, and rates are climbing as developers retire.
NATURAL-specific note: expertise in specific industries (banking, insurance) commands additional premiums due to specialization.
Latin America has a surprisingly strong NATURAL developer community rooted in large banking and insurance operations. Brazil and Mexico have had significant mainframe deployments supporting major financial institutions, and developers in these regions have deep NATURAL expertise. Many are eager to work remotely for US companies, expanding their opportunities beyond local legacy systems.
Time zone overlap: Most LatAm NATURAL developers are UTC-3 to UTC-5, giving 6-8 hours of real-time overlap with US East Coast. Mainframe work often requires on-call support and real-time troubleshooting, so synchronous availability matters.
Cost efficiency: A LatAm senior NATURAL developer costs 30-40% less than a US equivalent. Given NATURAL's scarcity and cost of replacement, LatAm talent offers exceptional value for critical legacy systems.
The NATURAL community in LatAm is active and committed. Developers understand the stakes of legacy system maintenance and approach their work with respect for stability and business continuity.
Cultural fit: LatAm developers tend to be detail-oriented and patient with legacy systems. They understand that boring, reliable code is often more valuable than flashy new features. This mindset is critical for mainframe environments.
Finding NATURAL developers is non-trivial. South has a specialized network of legacy language developers and can often source candidates when direct hiring fails.
Step 1: Share Requirements Tell us about your NATURAL systems. What industry? What scale? What are your immediate needs (maintenance, enhancement, modernization)? We'll match based on industry experience and technical depth.
Step 2: South Matches from Pre-vetted Network We screen for (1) deep NATURAL language expertise, (2) production system maintenance experience, (3) industry-specific knowledge (banking, insurance, etc.), and (4) ability to work on legacy systems without frustration. We prioritize developers who have shipped enhancements and understand business context.
Step 3: You Interview South facilitates interviews covering NATURAL technical depth, legacy system experience, and modernization thinking. We handle initial screening so your team talks to qualified candidates. Most teams make an offer within 1-2 interviews given scarcity.
Step 4: Ongoing Support Once hired, South handles payroll, compliance, and ensures retention support (NATURAL developers are critical and hard to replace). If a hire doesn't work out within 30 days, we replace them at no cost.
Ready to hire? Visit https://www.hireinsouth.com/start and tell us about your NATURAL systems. Given the scarcity, we typically need 5-10 days to source appropriate candidates.
NATURAL is used for maintaining and enhancing legacy business applications, particularly in banking, insurance, and large enterprises. It's not used for new development but remains critical for existing systems.
Yes and no. New NATURAL development is rare. But existing NATURAL systems are stable, and maintenance demand is constant. Developers are retiring, making NATURAL expertise increasingly scarce and valuable. The language will remain in use for decades, though with a shrinking developer base.
Gradual modernization (API wrapping, exposing via microservices) is often more practical than big rewrites. NATURAL is stable and well-tested; the business logic has value even if the language is old. Plan a phased approach rather than a rip-and-replace.
No. NATURAL talent is scarce and aging. South specializes in sourcing legacy language developers and can often find candidates when direct hiring fails. Expect longer timelines and premium rates due to scarcity.
Mid-level developers range $85K-125K/year. Senior developers go $140K-200K/year. Scarcity commands premium pricing.
Typically 5-10 days to source candidates due to scarcity. Interviews usually complete within 1-2 weeks. Total time from start to productive is 2-4 weeks.
Yes. South matches developers for full-time, part-time, and contract work. For code review or modernization consulting, part-time is common. Discuss scope at https://www.hireinsouth.com/start.
Most are UTC-3 to UTC-5 (Brazil, Argentina, Mexico). This gives 6-8 hours of overlap with US Eastern Time, critical for on-call support.
We assess (1) deep NATURAL language expertise (modules, data definitions, control flow), (2) production system maintenance and debugging experience, (3) industry-specific knowledge, and (4) ability to work on legacy systems without frustration. Practical assessments include code review and debugging.
South offers a 30-day replacement guarantee. If a developer doesn't work out, we match you with a replacement at no additional cost. Given scarcity, we work hard to get the right fit on the first try.
Yes. For large legacy systems requiring multiple maintainers, we can source teams of 2-3 developers. Team hires take longer (2-3 weeks) due to scarcity, but we prioritize cohesion.
