From your codebase to a knowledge graph you can explore
Send us your code. We parse it, connect it and turn it into reports, a website your teams can browse, and data exports for your own tools. When your code changes, send it again and the same process runs automatically.
Six steps, set up once
The first run is where we tailor everything to your environment. After that, the same process runs automatically every time you send new code.
- 01
Send us your codebase
You provide a package containing the codebase to be processed, typically through a secure SFTP server. That includes source code, scripts, scheduler definitions and run-time parameters: the production environment as it actually runs, without customer data or credentials of any kind.
- 02
We fill any gaps
If your environment uses a technology our parsers don’t yet support, including your own proprietary languages, we build a custom parser for it.
- 03
We set up the automation
We configure an automated process for your environment: unpack the codebase, identify every file, run the right parsers, resolve parameters and complete the additional processing your environment needs.
- 04
We build the knowledge graph
Every component, relationship and attribute lands in a single knowledge graph, held in our knowledge repository and connected across technologies, applications and platforms.
- 05
You receive the results
Reports and a website your teams can browse are generated from the knowledge graph. The results can also be exported as graphs, regulatory lineage summaries or raw data in a programmatically readable format such as JSON, for loading into your own tools.
- 06
Send updates whenever your code changes
When your codebase changes, send a new package. It’s processed automatically using the process set up during the first run, so your results stay current without starting over.
How we handle your code
Banks and insurers trust us with the code that runs their core systems. Here is how we look after it.
Your code stays on our servers
Your code is processed on Mapador’s own servers and never leaves them. We process in Canada by default, or in your own country when regulations require your code to stay in your jurisdiction.
No data, no credentials
Code packages arrive by secure SFTP. We don’t need any customer data or credentials of any kind, only the code, scripts and configuration that run your systems.
Certified infrastructure
Our servers are hosted in data centres that hold SOC 2 Type II attestation, the standard independent audit of security controls that banks and insurers expect.
What happens to your code
A simplified view of the automated process that runs on every package you send.
Ingest
- Receive client package
- Unpack
- Catalogue
Your package is unpacked and the received items are catalogued for further processing.
Recognize
- File type recognition
- Metadata collection
Each file is identified and its metadata collected for further processing and initial reporting.
Process
- Context-aware parsing
- Parameter resolution
- Dynamic code emulation
Fit-for-purpose parsers break code into components. Emulating dynamic expressions and resolving parameters provide the context needed to analyze embedded code.
Map
- Mapping
- Knowledge graph
Components and relationships are connected into one knowledge graph, whatever technology they came from.
Deliver
- PDF reports
- Mapador website
- Graph exports
- Regulatory lineage
- Custom exports
The website is organized around your focus. Graphs, regulatory lineage and raw data are exported in the formats you need.
Refresh: when your code changes, a new package runs through the same automated pipeline.
How your code actually behaves, across the entire codebase
Structure and logic
- Static code structure
- Function and method calls
- Conditions
- Control flows
Data and connections
- Data movements
- Database table and column accesses
- File reads and writes
- System connections
Use the results your way
A browsable website
A Mapador site organized around your focus, where your teams can navigate the knowledge graph, follow lineage, process flows and call trees, and jump into the source code.
Analysis reports
PDF reports summarizing the analysis, ready to share with teams and auditors.
Graph exports
Lineage, process flows and call trees as graph files in SVG or DOT format, which stay readable at any size and open in standard tools.
Regulatory lineage
Summarized lineage for regulatory reporting, delivered in your organization’s standard format.
Custom exports
Raw data from the knowledge graph in whatever format your tools need, such as JSON or CSV, for loading into catalogues, master data management (MDM) systems, analytics or AI tools.
Technologies we’ve handled
Enterprise systems are rarely built in one language. When we meet a technology we haven’t seen, we build a parser for it.
Mainframe and legacy
- COBOL
- PL/I
- FORTRAN
- Assembler
- JCL and JCL PROCs
- CICS
- IMS
- Easytrieve
- CA-GEN
- PowerBuilder
- Visual Basic
Databases and SQL
- SQL
- Teradata SQL
- Teradata FastLoad and MultiLoad
- Oracle SQL and PL/SQL
- T-SQL
- DB2
Schedulers
- Control-M
- Zeke
- CA7
ETL and data integration
- Talend
- IBM DataStage
- Metasuite
Scripting and analytics
- Unix shell scripts
- Perl
- Python
- SAS
Application languages
- Java and J2EE
- C
- C++
- C#
- JavaScript
- TypeScript
Your proprietary languages
Custom-built, in-house languages are no barrier. We’ve built parsers for clients’ own proprietary languages and connected them to everything else in the knowledge graph.
Running something we haven’t listed?
We build new parsers when a client needs one. Tell us what your environment runs and we’ll show you what we can map.

