How it works

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.

The process

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

Security

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.

Inside the pipeline

What happens to your code

A simplified view of the automated process that runs on every package you send.

  1. Ingest

    • Receive client package
    • Unpack
    • Catalogue

    Your package is unpacked and the received items are catalogued for further processing.

  2. Recognize

    • File type recognition
    • Metadata collection

    Each file is identified and its metadata collected for further processing and initial reporting.

  3. 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.

  4. Map

    • Mapping
    • Knowledge graph

    Components and relationships are connected into one knowledge graph, whatever technology they came from.

  5. 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.

What gets captured

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

See how lineage is built in levels

What you receive

Use the results your way

Explore

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.

Read

Analysis reports

PDF reports summarizing the analysis, ready to share with teams and auditors.

Visualize

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.

Comply

Regulatory lineage

Summarized lineage for regulatory reporting, delivered in your organization’s standard format.

Integrate

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

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.

Next step

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.