← Back to history

Pipeline run

cd93fe14-5232-4f4a-9142-89d77f31c0a0

Pipeline LLM cost (USD)
API 1: $0.0092 API 2: $0.0005 API 3: $0.0000 Total: $0.0096

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description
Nature of work · Network Software Engineering
Build and debug network software in C/Python/C++ for routing and VPN features, working on BGP/MPLS/IS-IS/SR/EVPN control-plane and data-plane protocols and integrating with network OS/FRR-style stacks.
"“Design, develop software solutions based on customer requirements.”"
Tech stack maturity
Mainstream Modern
The skill mix of C, distributed systems, microservices, and Python aligns with a modern engineering stack that is widely adopted but not bleeding-edge or legacy.
AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)
0.00 / 5
· Title match
· Has AI skill
· AI skill (primary)
· AI skill (secondary)
· On AI team
· Builds AI products
vocab breakdown (legacy)
Assistants (×1):
Frameworks (×2):
Models / concepts (×3):
Evidence — skills matched in JD (18)
C BGP L3VPN MPLS IS-IS Segment Routing EVPN Python C++ TCP/IP LDP L2VPN Control Plane Data Plane Microservices Distributed Systems FRR ZebOS
Skill cluster (4 dimension groups, role-scoped)
C# and .NET Languages
C C++
Performance and Scalability Tuning
Distributed Systems
Python Programming
Python
Cross-cutting / unaligned
BGP L3VPN MPLS IS-IS Segment Routing EVPN TCP/IP LDP L2VPN Control Plane Data Plane Microservices FRR ZebOS
Show KRA description ↓
• Strong work experience in Design and Development Using C language. • Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN • 8 years of experience in network programming and engineering. • Demonstrated time management, project planning and organizational. • Strong analytical and problem-solving skills. • Design, develop software solutions based on customer requirements. • Knowledge of programming and data-structures: C/Python/C++. • Knowledge of networking protocols (TCP/IP, Layer-3 protocols, MPLS, LDP, Segment-Routing, L2VPN, L3VPN both control-plane and data-plane) and networking devices. • Good understanding of Commercial/Opensource Network operating System. • Hand-on experience on FRR (Free Range Routing), ZebOS stack is preferred. • Prior experience in building asynchronous distributed system using microservices architecture and associated principles.

Signals

Skill backend-engineer
0.25
Alias network-engineer
1.00
KRA full-stack-engineer
0.41

Post-classification

Centroidupdated · n=1
Alias collision log
New-role queue
New skills captured13
New KRA capturedyes

Captured for admin review

BGP primary Network Engineer pending
L3VPN primary Network Engineer pending
MPLS primary Network Engineer pending
IS-IS primary Network Engineer pending
Segment Routing primary Network Engineer pending
EVPN primary Network Engineer pending
TCP/IP primary Network Engineer pending
LDP primary Network Engineer pending
L2VPN primary Network Engineer pending
Control Plane primary Network Engineer pending
Data Plane primary Network Engineer pending
FRR Network Engineer pending
ZebOS Network Engineer pending
R&R fragment (sim 0.00) Network Engineer pending

• Strong work experience in Design and Development Using C language. • Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN • 8 years of experience in network programming and engineering. • Demo…

Status: completed Created: 2026-05-27T14:00:57.257537Z Updated: 2026-05-27T14:03:23.941441Z API 3 duration: 43547 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Network Engineer

domain · Infrastructure & Networking CASE DOMAIN

slug: network-engineer · id: 179 · source: db

Domain=Infrastructure & Networking; The JD is centered on L2/L3 network programming with BGP, MPLS, ISIS, Segment Routing, EVPN, and routing protocol/software development, which best matches Network Engineer.

Matched skills

CBGPL3VPNMPLSISISSREVPNPythonC++TCP/IPLDPSegment-RoutingL2VPNFRRZebOS

Matched dimensions

Network Protocol EngineeringRouting and Switching DevelopmentNetwork Software DevelopmentDistributed Systems / MicroservicesNetwork Operating SystemsProblem Solving and Analytical Thinking

Matched KRAs

Design and development using C languageDesign, develop software solutions based on customer requirementsWork experience in BGP, L3VPN, MPLS, ISIS, SR, EVPNKnowledge of networking protocols and networking devicesGood understanding of Commercial/Opensource Network operating SystemHands-on experience on FRR and ZebOS stackBuilding asynchronous distributed system using microservices architecture

Resolution: in_db — role exists in library; skill↔dim and role↔dim links saved when applicable.

0
New skills
0
Skill↔dim saved
0
Role↔dim saved
0
Skipped

Job description

JD:-1 L2/L3 Network Programmer Engineer

 Job Overview:

The Networking Development Engineer - L2/L3 will be responsible for designing and developing networking protocols and features for our products in the L2/L3 domain. The ideal candidate will have a strong understanding of networking concepts and protocols, and experience with programming languages such as C/C++ or Python. The candidate will also work closely with cross-functional teams such as product management, QA, and support to ensure the success of the product.

 Key Responsibilities:

• Strong work experience in Design and Development Using C language.
• Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN
• 8 years of experience in network programming and engineering.
• Demonstrated time management, project planning and organizational.
• Strong analytical and problem-solving skills.


 Qualifications:

• Bachelor's degree in computer science, Electrical Engineering, or related field.
• Good understanding of Linux.
• Hand-on experience on FRR (Free Range Routing) stack.
• Knowledge on Docker, Kubernetes are optional.
• Excellent verbal and written communication skills.
• Quick learner who is self-driven and has a passion to excel


 JD:- 2- L2/L3 Network Programmer Engineer

 Key Responsibilities:

• Design, develop software solutions based on customer requirements.
• Knowledge of programming and data-structures: C/Python/C++.
• Knowledge of networking protocols (TCP/IP, Layer-3 protocols, MPLS, LDP, Segment-Routing, L2VPN, L3VPN both control-plane and data-plane) and networking devices.
• Good understanding of Commercial/Opensource Network operating System.
• Hand-on experience on FRR (Free Range Routing), ZebOS stack is preferred.
• Prior experience in building asynchronous distributed system using microservices architecture and associated principles.


 Qualifications:

• 7- 10 years experience in L3/MPLS/SR protocols.
• Bachelor's degree in Computer Science, Electrical Engineering, or related field.
• Hands on experience on Docker and Kubernetes.
• Experience of working in Agile/Scrum methodologies.


 Contact Details:

 Kaviya | Sr. recruiter

9500164554 | placements@vishanz.com

This job is provided by Shine.com

Skills from this JD

Each row merges API 1 extraction, API 2 library match / v3 orchestration (dimensions + locked dims), and API 3 persistence tags.

C Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: C# id=4 · c

Aliases — catalog

  • C# (CANONICAL) primary
  • C (CANONICAL)
  • C# 1 (VERSION)
  • C# 10 (VERSION)
  • C# 11 (VERSION)
  • C# 12 (VERSION)
  • C# 13 (VERSION)
  • C# 14 (VERSION)
  • C# 2 (VERSION)
  • C# 3 (VERSION)
  • C# 4 (VERSION)
  • C# 5 (VERSION)
  • C# 6 (VERSION)
  • C# 7 (VERSION)
  • C# 8 (VERSION)
  • C# 9 (VERSION)
  • C# latest (VERSION)
  • C#1 (VERSION)
  • C#10 (VERSION)
  • C#11 (VERSION)
  • C#12 (VERSION)
  • C#2 (VERSION)
  • C#3 (VERSION)
  • C#4 (VERSION)
  • C#5 (VERSION)
  • C#6 (VERSION)
  • C#7 (VERSION)
  • C#8 (VERSION)
  • C#9 (VERSION)
  • C++ (CANONICAL)
  • C++03 (VERSION)
  • C++11 (VERSION)
  • C++14 (VERSION)
  • C++17 (VERSION)
  • C++20 (VERSION)
  • C++23 (VERSION)
  • C++26 (VERSION)
  • C++98 (VERSION)
  • c sharp (VERSION)
  • c# (VERSION)
  • cpp03 (VERSION)
  • cpp11 (VERSION)
  • cpp14 (VERSION)
  • cpp17 (VERSION)
  • cpp20 (VERSION)
  • cpp23 (VERSION)
  • cpp26 (VERSION)
  • cpp98 (VERSION)
  • csharp (VERSION)
  • modern C++ (VERSION)

Context tags (catalog)

.NET ASP.NET Azure Boost C# 9 C11 C99 CLR CMake Entity Framework LINQ MSBuild MVC Makefile NuGet Qt RAII Roslyn STL TDD Unity Visual Studio WPF Web API WinForms Xamarin async/await attributes buffer overflow constexpr delegates dependency injection dynamic memory events free function pointer gcc gdb header files inline interfaces linker malloc memory leak memory management move semantics multithreading operator overloading pointer pointers preprocessor segmentation fault smart pointers stdio.h stdlib.h struct syntax error templates typedef xUnit

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Microsoft
License
mit
Year introduced
2000
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
latest

Maturity reasoning: C# is a mainstream hiring staple with high JD volume across .NET, Azure, and enterprise roles; Microsoft continues active platform investment in .NET, reinforcing broad adoption.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • C# and .NET Languages Catalog dimension db id 362

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Video Codec Languages and DSLs Catalog dimension db id 225

    Library dimension (catalog)

    Roles linked in library: Video Codec Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
BGP Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
L3VPN Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
MPLS Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
IS-IS Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Segment Routing Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
EVPN Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Python Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Python id=5 · python

Aliases — catalog

  • Python (CANONICAL) primary
  • Python 2 (VERSION)
  • Python 2.x (VERSION)
  • Python 3 (VERSION)
  • Python 3.10 (VERSION)
  • Python 3.11 (VERSION)
  • Python 3.12 (VERSION)
  • Python 3.x (VERSION)
  • py (VERSION)
  • py2 (VERSION)
  • py3 (VERSION)
  • python 3 (VERSION)
  • python 3.x (VERSION)
  • python2 (VERSION)
  • python3 (VERSION)
  • python3.x (VERSION)

Context tags (catalog)

API Django FastAPI Flask Jupyter NumPy PEP 8 Pandas REST SQLAlchemy asyncio pandas pip pytest type hints venv virtualenv

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
PSF
License
mit
Year introduced
1991
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
3

Maturity reasoning: Python appears in a very high volume of job descriptions across data, backend, automation, and ML roles, and remains a default hiring-pipeline language on major job boards and tech stacks.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Security Scripting & DSL Languages Catalog dimension db id 248

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • Programming Languages and Scripting Catalog dimension db id 59

    Library dimension (catalog)

    Roles linked in library: Cyber Security Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Python Programming Catalog dimension db id 290

    Library dimension (catalog)

    Roles linked in library: Python Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: C# id=4 · c

Aliases — catalog

  • C# (CANONICAL) primary
  • C (CANONICAL)
  • C# 1 (VERSION)
  • C# 10 (VERSION)
  • C# 11 (VERSION)
  • C# 12 (VERSION)
  • C# 13 (VERSION)
  • C# 14 (VERSION)
  • C# 2 (VERSION)
  • C# 3 (VERSION)
  • C# 4 (VERSION)
  • C# 5 (VERSION)
  • C# 6 (VERSION)
  • C# 7 (VERSION)
  • C# 8 (VERSION)
  • C# 9 (VERSION)
  • C# latest (VERSION)
  • C#1 (VERSION)
  • C#10 (VERSION)
  • C#11 (VERSION)
  • C#12 (VERSION)
  • C#2 (VERSION)
  • C#3 (VERSION)
  • C#4 (VERSION)
  • C#5 (VERSION)
  • C#6 (VERSION)
  • C#7 (VERSION)
  • C#8 (VERSION)
  • C#9 (VERSION)
  • C++ (CANONICAL)
  • C++03 (VERSION)
  • C++11 (VERSION)
  • C++14 (VERSION)
  • C++17 (VERSION)
  • C++20 (VERSION)
  • C++23 (VERSION)
  • C++26 (VERSION)
  • C++98 (VERSION)
  • c sharp (VERSION)
  • c# (VERSION)
  • cpp03 (VERSION)
  • cpp11 (VERSION)
  • cpp14 (VERSION)
  • cpp17 (VERSION)
  • cpp20 (VERSION)
  • cpp23 (VERSION)
  • cpp26 (VERSION)
  • cpp98 (VERSION)
  • csharp (VERSION)
  • modern C++ (VERSION)

Context tags (catalog)

.NET ASP.NET Azure Boost C# 9 C11 C99 CLR CMake Entity Framework LINQ MSBuild MVC Makefile NuGet Qt RAII Roslyn STL TDD Unity Visual Studio WPF Web API WinForms Xamarin async/await attributes buffer overflow constexpr delegates dependency injection dynamic memory events free function pointer gcc gdb header files inline interfaces linker malloc memory leak memory management move semantics multithreading operator overloading pointer pointers preprocessor segmentation fault smart pointers stdio.h stdlib.h struct syntax error templates typedef xUnit

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
Microsoft
License
mit
Year introduced
2000
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
latest

Maturity reasoning: C# is a mainstream hiring staple with high JD volume across .NET, Azure, and enterprise roles; Microsoft continues active platform investment in .NET, reinforcing broad adoption.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • C# and .NET Languages Catalog dimension db id 362

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Video Codec Languages and DSLs Catalog dimension db id 225

    Library dimension (catalog)

    Roles linked in library: Video Codec Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TCP/IP Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
LDP Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
L2VPN Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Control Plane Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
Data Plane Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
FRR Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
ZebOS Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Networking
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Microservices Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: microservices id=41 · microservices

Aliases — catalog

  • microservices (CANONICAL) primary

Context tags (catalog)

API Gateway API gateway CQRS DevOps Docker Kubernetes REST API RESTful services Saga pattern Spring Boot circuit breaker containerization decentralized distributed tracing domain-driven design event sourcing event-driven event-driven architecture gRPC load balancing message broker microservices patterns monitoring scalability service discovery service mesh

Stored enrichment (catalog DB)

Category
Architecture
Sub-category
Distributed System Architecture
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Microservices is a common architecture in job descriptions across backend/cloud roles, and major vendors like AWS, Google Cloud, and Kubernetes ecosystems provide first-class support and reference patterns.

Skill profile (library / DB)

Skill nature
PATTERN
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
1
Sub-category id
1
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Microservices and Distributed Systems Catalog dimension db id 9

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Node.js Backend Developer, Scala Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Microservices and Distributed Systems
microservices-and-distributed-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Distributed Systems Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Distributed Systems id=1369 · distributed-systems

Aliases — catalog

  • Distributed Systems (CANONICAL)

Context tags (catalog)

CAP theorem Docker Swarm Kafka MapReduce Zookeeper consensus algorithms distributed databases eventual consistency fault tolerance gRPC load balancing message queues microservices replication sharding

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Distributed Systems
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Common hiring requirement in backend/platform JDs at large tech firms; appears across AWS, Kafka, microservices, and systems roles, with strong GitHub/Stack Overflow activity and no sunset signal.

Skill profile (library / DB)

Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
2
Sub-category id
1035
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Cyber Security Engineer, Data Engineer, DevOps Engineer, Fullstack Developer, Go Backend Developer, Java Backend Developer, Kotlin Backend Developer, ML Engineer, MLOps Engineer, Node.js Backend Developer, Python Backend Developer, Scala Backend Developer

  • Performance and Scalability Tuning Catalog dimension db id 11

    Library dimension (catalog)

    Roles linked in library: .NET Backend Developer, Backend Developer, Node.js Backend Developer, PHP Backend Developer, Python Backend Developer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Performance and Scalability Tuning
performance-and-scalability-tuning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

All API 3 persistence rows

Same grid as the skill-extractor “Persistence items” table: one row per (skill × dimension) work item.

Skill Tag Dimension Skill↔dim Role↔dim Outcome Notes
C in_db
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C in_db
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Python Programming
python-programming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
C# and .NET Languages
c-and-net-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
C++ in_db
Video Codec Languages and DSLs
video-codec-languages-and-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Microservices in_db
Microservices and Distributed Systems
microservices-and-distributed-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Distributed Systems in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Distributed Systems in_db
Performance and Scalability Tuning
performance-and-scalability-tuning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Distributed Systems in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed BGP | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed L3VPN | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed MPLS | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed IS-IS | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed Segment Routing | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed EVPN | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed TCP/IP | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed LDP | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed L2VPN | type=Networking subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed Control Plane | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Data Plane | type=Networking subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed FRR | type=Networking subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed ZebOS | type=Networking subtype=general nature=TOOL lifespan=MULTI_YEAR
nano JD Parser — gpt-4.1-nano click to toggle
RoleL2/L3 Network Programmer Engineer
CompanyVishanz
Experience7-10 years experience in L3/MPLS/SR protocols.
DomainIT Services & Consulting
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": "Vishanz",
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "ITES",
        "BPO"
      ],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [
    {
      "level": "Bachelor\u0027s",
      "qualification": "BTECH/BE - Computer Science / Electrical Engineering (or related)",
      "raw": "Bachelor\u0027s degree in Computer Science, Electrical Engineering, or related field.",
      "requirement": "required"
    }
  ],
  "experience": {
    "max": 10,
    "min": 7,
    "raw": "7-10 years experience in L3/MPLS/SR protocols."
  },
  "job_locations": [],
  "role": "L2/L3 Network Programmer Engineer",
  "role_aliases": [
    "Network Engineer",
    "Network Programmer",
    "L2/L3 Engineer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 5,
      "heading": "Key Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "\u2022 Strong work experience in",
        "last_5_words": "analytical and problem-solving skills."
      },
      "text": "\u2022 Strong work experience in Design and Development Using C language.\n\u2022 Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN\n\u2022 8 years of experience in network programming and engineering.\n\u2022 Demonstrated time management, project planning and organizational.\n\u2022 Strong analytical and problem-solving skills.",
      "word_count": 43
    },
    {
      "bullet_count": 6,
      "heading": "Key Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "\u2022 Design, develop software solutions",
        "last_5_words": "architecture and associated principles."
      },
      "text": "\u2022 Design, develop software solutions based on customer requirements.\n\u2022 Knowledge of programming and data-structures: C/Python/C++.\n\u2022 Knowledge of networking protocols (TCP/IP, Layer-3 protocols, MPLS, LDP, Segment-Routing, L2VPN, L3VPN both control-plane and data-plane) and networking devices.\n\u2022 Good understanding of Commercial/Opensource Network operating System.\n\u2022 Hand-on experience on FRR (Free Range Routing), ZebOS stack is preferred.\n\u2022 Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
      "word_count": 66
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "C"
    },
    {
      "is_primary": true,
      "skill_name": "BGP"
    },
    {
      "is_primary": true,
      "skill_name": "L3VPN"
    },
    {
      "is_primary": true,
      "skill_name": "MPLS"
    },
    {
      "is_primary": true,
      "skill_name": "IS-IS"
    },
    {
      "is_primary": true,
      "skill_name": "Segment Routing"
    },
    {
      "is_primary": true,
      "skill_name": "EVPN"
    },
    {
      "is_primary": true,
      "skill_name": "Python"
    },
    {
      "is_primary": true,
      "skill_name": "C++"
    },
    {
      "is_primary": true,
      "skill_name": "TCP/IP"
    },
    {
      "is_primary": true,
      "skill_name": "LDP"
    },
    {
      "is_primary": true,
      "skill_name": "L2VPN"
    },
    {
      "is_primary": true,
      "skill_name": "Control Plane"
    },
    {
      "is_primary": true,
      "skill_name": "Data Plane"
    },
    {
      "is_primary": false,
      "skill_name": "FRR"
    },
    {
      "is_primary": false,
      "skill_name": "ZebOS"
    },
    {
      "is_primary": true,
      "skill_name": "Microservices"
    },
    {
      "is_primary": true,
      "skill_name": "Distributed Systems"
    }
  ],
  "jd_role": {
    "display_name": "L2/L3 Network Programmer Engineer",
    "rationale": null,
    "role_aliases": [
      "Network Engineer",
      "Network Programmer",
      "L2/L3 Engineer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": "Vishanz",
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "ITES",
          "BPO"
        ],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [
      {
        "level": "Bachelor\u0027s",
        "qualification": "BTECH/BE - Computer Science / Electrical Engineering (or related)",
        "raw": "Bachelor\u0027s degree in Computer Science, Electrical Engineering, or related field.",
        "requirement": "required"
      }
    ],
    "experience": {
      "max": 10,
      "min": 7,
      "raw": "7-10 years experience in L3/MPLS/SR protocols."
    },
    "job_locations": [],
    "role": "L2/L3 Network Programmer Engineer",
    "role_aliases": [
      "Network Engineer",
      "Network Programmer",
      "L2/L3 Engineer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 5,
        "heading": "Key Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "\u2022 Strong work experience in",
          "last_5_words": "analytical and problem-solving skills."
        },
        "text": "\u2022 Strong work experience in Design and Development Using C language.\n\u2022 Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN\n\u2022 8 years of experience in network programming and engineering.\n\u2022 Demonstrated time management, project planning and organizational.\n\u2022 Strong analytical and problem-solving skills.",
        "word_count": 43
      },
      {
        "bullet_count": 6,
        "heading": "Key Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "\u2022 Design, develop software solutions",
          "last_5_words": "architecture and associated principles."
        },
        "text": "\u2022 Design, develop software solutions based on customer requirements.\n\u2022 Knowledge of programming and data-structures: C/Python/C++.\n\u2022 Knowledge of networking protocols (TCP/IP, Layer-3 protocols, MPLS, LDP, Segment-Routing, L2VPN, L3VPN both control-plane and data-plane) and networking devices.\n\u2022 Good understanding of Commercial/Opensource Network operating System.\n\u2022 Hand-on experience on FRR (Free Range Routing), ZebOS stack is preferred.\n\u2022 Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
        "word_count": 66
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "cd93fe14-5232-4f4a-9142-89d77f31c0a0",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "Network Engineer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 179,
        "score": 1.0,
        "slug": "network-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": [
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "Design, develop software solutions based on customer requirements.",
            "similarity": 0.5234
          },
          {
            "kra_text": "Writes application logic across the presentation layer, service layer, and data access layer of web applications following MVC or clean architecture patterns.",
            "sentence": "Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
            "similarity": 0.3606
          },
          {
            "kra_text": "Works closely with product managers and UX designers to translate requirements and wireframes into working software features through iterative development.",
            "sentence": "Strong work experience in Design and Development Using C language.",
            "similarity": 0.3578
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.4139,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Java Backend Developer",
        "kra_matches": [
          {
            "kra_text": "asynchronous job processing",
            "sentence": "Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
            "similarity": 0.4381
          },
          {
            "kra_text": "service endpoint development",
            "sentence": "Design, develop software solutions based on customer requirements.",
            "similarity": 0.4165
          },
          {
            "kra_text": "code refactoring and defect fixes",
            "sentence": "Strong work experience in Design and Development Using C language.",
            "similarity": 0.3414
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 79,
        "score": 0.3987,
        "slug": "java-backend-developer",
        "total_count": null
      },
      {
        "display_name": "Flutter Developer",
        "kra_matches": [
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Design, develop software solutions based on customer requirements.",
            "similarity": 0.4763
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
            "similarity": 0.3575
          },
          {
            "kra_text": "translate product and design requirements",
            "sentence": "Strong work experience in Design and Development Using C language.",
            "similarity": 0.3512
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 74,
        "score": 0.395,
        "slug": "flutter-developer",
        "total_count": null
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": [
          {
            "kra_text": "Integrates with third-party services, payment gateways, messaging queues like Kafka or RabbitMQ, and internal microservices via HTTP and event-driven patterns.",
            "sentence": "Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
            "similarity": 0.4627
          },
          {
            "kra_text": "Investigates and resolves production incidents, API bugs, and service degradation through root cause analysis, hotfixes, and post-mortems.",
            "sentence": "Design, develop software solutions based on customer requirements.",
            "similarity": 0.3605
          },
          {
            "kra_text": "Investigates and resolves production incidents, API bugs, and service degradation through root cause analysis, hotfixes, and post-mortems.",
            "sentence": "Strong analytical and problem-solving skills.",
            "similarity": 0.3558
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 1,
        "score": 0.393,
        "slug": "backend-engineer",
        "total_count": null
      },
      {
        "display_name": "Cloud Architect",
        "kra_matches": [
          {
            "kra_text": "Conducts architecture reviews, approves technical design documents, and guides engineering teams through cloud migration and modernization projects.",
            "sentence": "Design, develop software solutions based on customer requirements.",
            "similarity": 0.4234
          },
          {
            "kra_text": "Designs multi-region and multi-availability-zone cloud infrastructure architectures for high availability, fault tolerance, and horizontal scalability.",
            "sentence": "Prior experience in building asynchronous distributed system using microservices architecture and associated principles.",
            "similarity": 0.3851
          },
          {
            "kra_text": "Designs IAM policies, service control policies, VPC segmentation, private endpoints, and zero-trust network access boundaries for cloud environments.",
            "sentence": "Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN",
            "similarity": 0.3638
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 9,
        "score": 0.3908,
        "slug": "cloud-architect",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Backend Developer",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "C#",
          "Distributed Systems",
          "Python",
          "microservices"
        ],
        "role_id": 1,
        "score": 0.25,
        "slug": "backend-engineer",
        "total_count": 16
      },
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "C#",
          "Distributed Systems",
          "Python"
        ],
        "role_id": 15,
        "score": 0.1875,
        "slug": "full-stack-engineer",
        "total_count": 16
      },
      {
        "display_name": "ML Engineer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "C#",
          "Distributed Systems",
          "Python"
        ],
        "role_id": 3,
        "score": 0.1875,
        "slug": "ml-engineer",
        "total_count": 16
      },
      {
        "display_name": "MLOps Engineer",
        "kra_matches": null,
        "matched_count": 3,
        "matched_skills": [
          "C#",
          "Distributed Systems",
          "Python"
        ],
        "role_id": 16,
        "score": 0.1875,
        "slug": "ml-ops-engineer",
        "total_count": 16
      },
      {
        "display_name": "AR/VR Engineer",
        "kra_matches": null,
        "matched_count": 2,
        "matched_skills": [
          "C#",
          "Python"
        ],
        "role_id": 8,
        "score": 0.125,
        "slug": "ar-vr-engineer",
        "total_count": 16
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "DOMAIN",
    "chosen_role": {
      "display_name": "Network Engineer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 179,
      "score": 0.98,
      "slug": "network-engineer",
      "total_count": null
    },
    "confidence": 0.98,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [
      "Network Protocol Engineering",
      "Routing and Switching Development",
      "Network Software Development",
      "Distributed Systems / Microservices",
      "Network Operating Systems",
      "Problem Solving and Analytical Thinking"
    ],
    "matched_kras": [
      "Design and development using C language",
      "Design, develop software solutions based on customer requirements",
      "Work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN",
      "Knowledge of networking protocols and networking devices",
      "Good understanding of Commercial/Opensource Network operating System",
      "Hands-on experience on FRR and ZebOS stack",
      "Building asynchronous distributed system using microservices architecture"
    ],
    "matched_skills": [
      "C",
      "BGP",
      "L3VPN",
      "MPLS",
      "ISIS",
      "SR",
      "EVPN",
      "Python",
      "C++",
      "TCP/IP",
      "LDP",
      "Segment-Routing",
      "L2VPN",
      "FRR",
      "ZebOS"
    ],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Domain=Infrastructure \u0026 Networking; The JD is centered on L2/L3 network programming with BGP, MPLS, ISIS, Segment Routing, EVPN, and routing protocol/software development, which best matches Network Engineer.",
    "sub_role": null
  },
  "stage5_updates": {
    "centroid_n_after": 1,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": {
      "best_kra_similarity": 0.0,
      "queue_id": 326,
      "r_and_r_preview": "\u2022 Strong work experience in Design and Development Using C language.\n\u2022 Strong work experience in BGP, L3VPN, MPLS, ISIS, SR, EVPN\n\u2022 8 years of experience in network programming and engineering.\n\u2022 Demo",
      "role_display_name": "Network Engineer",
      "role_slug": "network-engineer",
      "status": "pending"
    },
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 6391,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "BGP",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6392,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "L3VPN",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6393,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "MPLS",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6394,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "IS-IS",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6395,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "Segment Routing",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6396,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "EVPN",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6397,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "TCP/IP",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6398,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "LDP",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6399,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "L2VPN",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6400,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "Control Plane",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 6401,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "Data Plane",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 6402,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "FRR",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 6403,
        "role_display_name": "Network Engineer",
        "role_slug": "network-engineer",
        "skill_name": "ZebOS",
        "status": "pending"
      }
    ],
    "queue_entry_id": null,
    "v3_pipeline_triggered": false,
    "v3_role_slug": null,
    "v3_run_id": null
  }
}
API 2 — extract-details
{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1609,
      "existing_alias_text": "C",
      "input_term": "C",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 67,
      "existing_alias_text": "Python",
      "input_term": "Python",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 418,
      "existing_alias_text": "C++",
      "input_term": "C++",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 178,
      "existing_alias_text": "microservices",
      "input_term": "Microservices",
      "matched_canonical": {
        "category_id": 1,
        "display_name": "microservices",
        "id": 41,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "microservices",
        "sub_category_id": 1,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2028,
      "existing_alias_text": "Distributed Systems",
      "input_term": "Distributed Systems",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "Distributed Systems",
        "id": 1369,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "distributed-systems",
        "sub_category_id": 1035,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Backend Developer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "MLOps Engineer",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-ops-engineer",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": "Sitecore Dev",
      "id": 233,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "sitecore-dev",
      "source": "db"
    },
    {
      "display_name": "Video Codec Engineer",
      "id": 22,
      "rationale": null,
      "role_archetype": null,
      "slug": "video-codec-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Cyber Security Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "Python Backend Developer",
      "id": 80,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "python-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Node.js Backend Developer",
      "id": 82,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "node-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Java Backend Developer",
      "id": 79,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "java-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Kotlin Backend Developer",
      "id": 84,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "kotlin-server-backend-developer",
      "source": "db"
    },
    {
      "display_name": "PHP Backend Developer",
      "id": 86,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "php-backend-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Network Engineer",
    "id": 179,
    "rationale": "Domain=Infrastructure \u0026 Networking; The JD is centered on L2/L3 network programming with BGP, MPLS, ISIS, Segment Routing, EVPN, and routing protocol/software development, which best matches Network Engineer.",
    "role_archetype": null,
    "slug": "network-engineer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "C# and .NET Languages",
        "id": 362,
        "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
        "slug": "c-and-net-languages",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Video Codec Languages and DSLs",
        "id": 225,
        "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
        "slug": "video-codec-languages-and-dsls",
        "source": "db"
      },
      "input_skill": "C",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Video Codec Engineer",
          "id": 22,
          "rationale": null,
          "role_archetype": null,
          "slug": "video-codec-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Scripting \u0026 DSL Languages",
        "id": 248,
        "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
        "slug": "cloud-security-scripting-dsl-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages and Scripting",
        "id": 59,
        "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
        "slug": "programming-languages-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Python Programming",
        "id": 290,
        "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
        "slug": "python-programming",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "C# and .NET Languages",
        "id": 362,
        "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
        "slug": "c-and-net-languages",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Video Codec Languages and DSLs",
        "id": 225,
        "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
        "slug": "video-codec-languages-and-dsls",
        "source": "db"
      },
      "input_skill": "C++",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Video Codec Engineer",
          "id": 22,
          "rationale": null,
          "role_archetype": null,
          "slug": "video-codec-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Microservices and Distributed Systems",
        "id": 9,
        "rationale": "Architectural patterns for decomposed backend systems and the operational concerns they introduce. Covers service boundaries, consistency tradeoffs, retries, circuit breakers, and distributed coordination.",
        "slug": "microservices-and-distributed-systems",
        "source": "db"
      },
      "input_skill": "Microservices",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "Distributed Systems",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        },
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Performance and Scalability Tuning",
        "id": 11,
        "rationale": "Techniques for improving throughput, latency, and resource efficiency in PHP backend services. This includes profiling, query optimization, concurrency limits, memory use, and bottleneck analysis.",
        "slug": "performance-and-scalability-tuning",
        "source": "db"
      },
      "input_skill": "Distributed Systems",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Distributed Systems",
      "llm_role": null,
      "roles_from_db": []
    }
  ],
  "input_final_skills": [
    "C",
    "BGP",
    "L3VPN",
    "MPLS",
    "IS-IS",
    "Segment Routing",
    "EVPN",
    "Python",
    "C++",
    "TCP/IP",
    "LDP",
    "L2VPN",
    "Control Plane",
    "Data Plane",
    "FRR",
    "ZebOS",
    "Microservices",
    "Distributed Systems"
  ],
  "input_llm_skills": [
    "C",
    "BGP",
    "L3VPN",
    "MPLS",
    "IS-IS",
    "Segment Routing",
    "EVPN",
    "Python",
    "C++",
    "TCP/IP",
    "LDP",
    "L2VPN",
    "Control Plane",
    "Data Plane",
    "FRR",
    "ZebOS",
    "Microservices",
    "Distributed Systems"
  ],
  "new_aliases_persisted": 0,
  "run_id": "cd93fe14-5232-4f4a-9142-89d77f31c0a0",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "C#",
          "alias_type": "CANONICAL",
          "id": 52,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C",
          "alias_type": "CANONICAL",
          "id": 1609,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 1",
          "alias_type": "VERSION",
          "id": 53,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 10",
          "alias_type": "VERSION",
          "id": 62,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 11",
          "alias_type": "VERSION",
          "id": 63,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 12",
          "alias_type": "VERSION",
          "id": 64,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 13",
          "alias_type": "VERSION",
          "id": 65,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 14",
          "alias_type": "VERSION",
          "id": 66,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 2",
          "alias_type": "VERSION",
          "id": 54,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 3",
          "alias_type": "VERSION",
          "id": 55,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 4",
          "alias_type": "VERSION",
          "id": 56,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 5",
          "alias_type": "VERSION",
          "id": 57,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 6",
          "alias_type": "VERSION",
          "id": 58,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 7",
          "alias_type": "VERSION",
          "id": 59,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 8",
          "alias_type": "VERSION",
          "id": 60,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 9",
          "alias_type": "VERSION",
          "id": 61,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# latest",
          "alias_type": "VERSION",
          "id": 1655,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#1",
          "alias_type": "VERSION",
          "id": 2228,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#10",
          "alias_type": "VERSION",
          "id": 2246,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#11",
          "alias_type": "VERSION",
          "id": 2247,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#12",
          "alias_type": "VERSION",
          "id": 2248,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#2",
          "alias_type": "VERSION",
          "id": 2229,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#3",
          "alias_type": "VERSION",
          "id": 2230,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#4",
          "alias_type": "VERSION",
          "id": 2231,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#5",
          "alias_type": "VERSION",
          "id": 2232,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#6",
          "alias_type": "VERSION",
          "id": 2233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#7",
          "alias_type": "VERSION",
          "id": 2234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#8",
          "alias_type": "VERSION",
          "id": 2235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#9",
          "alias_type": "VERSION",
          "id": 2236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++",
          "alias_type": "CANONICAL",
          "id": 418,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++03",
          "alias_type": "VERSION",
          "id": 420,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++11",
          "alias_type": "VERSION",
          "id": 421,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++14",
          "alias_type": "VERSION",
          "id": 422,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++17",
          "alias_type": "VERSION",
          "id": 423,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++20",
          "alias_type": "VERSION",
          "id": 424,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++23",
          "alias_type": "VERSION",
          "id": 425,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++26",
          "alias_type": "VERSION",
          "id": 426,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++98",
          "alias_type": "VERSION",
          "id": 427,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c sharp",
          "alias_type": "VERSION",
          "id": 4765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c#",
          "alias_type": "VERSION",
          "id": 4763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp03",
          "alias_type": "VERSION",
          "id": 879,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp11",
          "alias_type": "VERSION",
          "id": 880,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp14",
          "alias_type": "VERSION",
          "id": 881,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp17",
          "alias_type": "VERSION",
          "id": 882,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp20",
          "alias_type": "VERSION",
          "id": 883,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp23",
          "alias_type": "VERSION",
          "id": 884,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp26",
          "alias_type": "VERSION",
          "id": 885,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp98",
          "alias_type": "VERSION",
          "id": 886,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "csharp",
          "alias_type": "VERSION",
          "id": 4764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "modern C++",
          "alias_type": "VERSION",
          "id": 428,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "C# and .NET Languages",
            "id": 362,
            "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
            "slug": "c-and-net-languages",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Video Codec Languages and DSLs",
            "id": 225,
            "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
            "slug": "video-codec-languages-and-dsls",
            "source": "db"
          },
          "input_skill": "C",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Video Codec Engineer",
              "id": 22,
              "rationale": null,
              "role_archetype": null,
              "slug": "video-codec-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "C",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "BGP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "bgp",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "L3VPN",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "l3vpn",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "MPLS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "mpls",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "IS-IS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "is-is",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Segment Routing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "segment-routing",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "EVPN",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "evpn",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Python",
          "alias_type": "CANONICAL",
          "id": 67,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2",
          "alias_type": "VERSION",
          "id": 72,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2.x",
          "alias_type": "VERSION",
          "id": 74,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3",
          "alias_type": "VERSION",
          "id": 73,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.10",
          "alias_type": "VERSION",
          "id": 76,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.11",
          "alias_type": "VERSION",
          "id": 77,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.12",
          "alias_type": "VERSION",
          "id": 78,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.x",
          "alias_type": "VERSION",
          "id": 75,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py",
          "alias_type": "VERSION",
          "id": 2183,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py2",
          "alias_type": "VERSION",
          "id": 68,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py3",
          "alias_type": "VERSION",
          "id": 69,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3",
          "alias_type": "VERSION",
          "id": 2186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.x",
          "alias_type": "VERSION",
          "id": 2849,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python2",
          "alias_type": "VERSION",
          "id": 70,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3",
          "alias_type": "VERSION",
          "id": 71,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3.x",
          "alias_type": "VERSION",
          "id": 2848,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Scripting \u0026 DSL Languages",
            "id": 248,
            "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
            "slug": "cloud-security-scripting-dsl-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages and Scripting",
            "id": 59,
            "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
            "slug": "programming-languages-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Python Programming",
            "id": 290,
            "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
            "slug": "python-programming",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Python",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "C#",
          "alias_type": "CANONICAL",
          "id": 52,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C",
          "alias_type": "CANONICAL",
          "id": 1609,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 1",
          "alias_type": "VERSION",
          "id": 53,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 10",
          "alias_type": "VERSION",
          "id": 62,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 11",
          "alias_type": "VERSION",
          "id": 63,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 12",
          "alias_type": "VERSION",
          "id": 64,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 13",
          "alias_type": "VERSION",
          "id": 65,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 14",
          "alias_type": "VERSION",
          "id": 66,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 2",
          "alias_type": "VERSION",
          "id": 54,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 3",
          "alias_type": "VERSION",
          "id": 55,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 4",
          "alias_type": "VERSION",
          "id": 56,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 5",
          "alias_type": "VERSION",
          "id": 57,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 6",
          "alias_type": "VERSION",
          "id": 58,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 7",
          "alias_type": "VERSION",
          "id": 59,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 8",
          "alias_type": "VERSION",
          "id": 60,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# 9",
          "alias_type": "VERSION",
          "id": 61,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C# latest",
          "alias_type": "VERSION",
          "id": 1655,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#1",
          "alias_type": "VERSION",
          "id": 2228,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#10",
          "alias_type": "VERSION",
          "id": 2246,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#11",
          "alias_type": "VERSION",
          "id": 2247,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#12",
          "alias_type": "VERSION",
          "id": 2248,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#2",
          "alias_type": "VERSION",
          "id": 2229,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#3",
          "alias_type": "VERSION",
          "id": 2230,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#4",
          "alias_type": "VERSION",
          "id": 2231,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#5",
          "alias_type": "VERSION",
          "id": 2232,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#6",
          "alias_type": "VERSION",
          "id": 2233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#7",
          "alias_type": "VERSION",
          "id": 2234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#8",
          "alias_type": "VERSION",
          "id": 2235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C#9",
          "alias_type": "VERSION",
          "id": 2236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++",
          "alias_type": "CANONICAL",
          "id": 418,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++03",
          "alias_type": "VERSION",
          "id": 420,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++11",
          "alias_type": "VERSION",
          "id": 421,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++14",
          "alias_type": "VERSION",
          "id": 422,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++17",
          "alias_type": "VERSION",
          "id": 423,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++20",
          "alias_type": "VERSION",
          "id": 424,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++23",
          "alias_type": "VERSION",
          "id": 425,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++26",
          "alias_type": "VERSION",
          "id": 426,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "C++98",
          "alias_type": "VERSION",
          "id": 427,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c sharp",
          "alias_type": "VERSION",
          "id": 4765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "c#",
          "alias_type": "VERSION",
          "id": 4763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp03",
          "alias_type": "VERSION",
          "id": 879,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp11",
          "alias_type": "VERSION",
          "id": 880,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp14",
          "alias_type": "VERSION",
          "id": 881,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp17",
          "alias_type": "VERSION",
          "id": 882,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp20",
          "alias_type": "VERSION",
          "id": 883,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp23",
          "alias_type": "VERSION",
          "id": 884,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp26",
          "alias_type": "VERSION",
          "id": 885,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "cpp98",
          "alias_type": "VERSION",
          "id": 886,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "csharp",
          "alias_type": "VERSION",
          "id": 4764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "modern C++",
          "alias_type": "VERSION",
          "id": 428,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "C#",
        "id": 4,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "c",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "C# and .NET Languages",
            "id": 362,
            "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
            "slug": "c-and-net-languages",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Video Codec Languages and DSLs",
            "id": 225,
            "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
            "slug": "video-codec-languages-and-dsls",
            "source": "db"
          },
          "input_skill": "C++",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Video Codec Engineer",
              "id": 22,
              "rationale": null,
              "role_archetype": null,
              "slug": "video-codec-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "C++",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "TCP/IP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "tcp-ip",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "LDP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "ldp",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "L2VPN",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "l2vpn",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Control Plane",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "control-plane",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Data Plane",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "data-plane",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "FRR",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "frr",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "ZebOS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Networking",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "zebos",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "microservices",
          "alias_type": "CANONICAL",
          "id": 178,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 1,
        "display_name": "microservices",
        "id": 41,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "microservices",
        "sub_category_id": 1,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Microservices and Distributed Systems",
            "id": 9,
            "rationale": "Architectural patterns for decomposed backend systems and the operational concerns they introduce. Covers service boundaries, consistency tradeoffs, retries, circuit breakers, and distributed coordination.",
            "slug": "microservices-and-distributed-systems",
            "source": "db"
          },
          "input_skill": "Microservices",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Microservices",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Distributed Systems",
          "alias_type": "CANONICAL",
          "id": 2028,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "Distributed Systems",
        "id": 1369,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "distributed-systems",
        "sub_category_id": 1035,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "Distributed Systems",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            },
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Performance and Scalability Tuning",
            "id": 11,
            "rationale": "Techniques for improving throughput, latency, and resource efficiency in PHP backend services. This includes profiling, query optimization, concurrency limits, memory use, and bottleneck analysis.",
            "slug": "performance-and-scalability-tuning",
            "source": "db"
          },
          "input_skill": "Distributed Systems",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Distributed Systems",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Distributed Systems",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "BGP",
    "L3VPN",
    "MPLS",
    "IS-IS",
    "Segment Routing",
    "EVPN",
    "TCP/IP",
    "LDP",
    "L2VPN",
    "Control Plane",
    "Data Plane",
    "FRR",
    "ZebOS"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Network Engineer",
    "id": 179,
    "rationale": "Domain=Infrastructure \u0026 Networking; The JD is centered on L2/L3 network programming with BGP, MPLS, ISIS, Segment Routing, EVPN, and routing protocol/software development, which best matches Network Engineer.",
    "role_archetype": null,
    "slug": "network-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "C",
      "tag": "in_db"
    },
    {
      "skill": "BGP",
      "tag": "new"
    },
    {
      "skill": "L3VPN",
      "tag": "new"
    },
    {
      "skill": "MPLS",
      "tag": "new"
    },
    {
      "skill": "IS-IS",
      "tag": "new"
    },
    {
      "skill": "Segment Routing",
      "tag": "new"
    },
    {
      "skill": "EVPN",
      "tag": "new"
    },
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "C++",
      "tag": "in_db"
    },
    {
      "skill": "TCP/IP",
      "tag": "new"
    },
    {
      "skill": "LDP",
      "tag": "new"
    },
    {
      "skill": "L2VPN",
      "tag": "new"
    },
    {
      "skill": "Control Plane",
      "tag": "new"
    },
    {
      "skill": "Data Plane",
      "tag": "new"
    },
    {
      "skill": "FRR",
      "tag": "new"
    },
    {
      "skill": "ZebOS",
      "tag": "new"
    },
    {
      "skill": "Microservices",
      "tag": "in_db"
    },
    {
      "skill": "Distributed Systems",
      "tag": "in_db"
    }
  ],
  "llm_cost_api1_usd": null,
  "llm_cost_api2_usd": null,
  "llm_cost_api3_usd": null,
  "llm_cost_total_usd": null,
  "persistence": {
    "items": [
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "C# and .NET Languages",
          "id": 362,
          "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
          "slug": "c-and-net-languages",
          "source": "db"
        },
        "dimension_id": 362,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Video Codec Languages and DSLs",
          "id": 225,
          "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
          "slug": "video-codec-languages-and-dsls",
          "source": "db"
        },
        "dimension_id": 225,
        "input_skill": "C",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Video Codec Engineer",
            "id": 22,
            "rationale": null,
            "role_archetype": null,
            "slug": "video-codec-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Scripting \u0026 DSL Languages",
          "id": 248,
          "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
          "slug": "cloud-security-scripting-dsl-languages",
          "source": "db"
        },
        "dimension_id": 248,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages and Scripting",
          "id": 59,
          "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
          "slug": "programming-languages-and-scripting",
          "source": "db"
        },
        "dimension_id": 59,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Python Programming",
          "id": 290,
          "rationale": "Core Python language skills used to implement backend business logic, request handlers, integrations, and service internals. This is the primary coding surface for the role.",
          "slug": "python-programming",
          "source": "db"
        },
        "dimension_id": 290,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "C# and .NET Languages",
          "id": 362,
          "rationale": "Primary implementation languages and runtime features used to build backend service logic in the .NET ecosystem. This is the core coding surface for request handling, domain logic, and service internals.",
          "slug": "c-and-net-languages",
          "source": "db"
        },
        "dimension_id": 362,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Video Codec Languages and DSLs",
          "id": 225,
          "rationale": "Implementation languages and codec-specific description languages used to build compression, decoding, and transform logic. This is the primary coding surface for codec behavior and bitstream manipulation.",
          "slug": "video-codec-languages-and-dsls",
          "source": "db"
        },
        "dimension_id": 225,
        "input_skill": "C++",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Video Codec Engineer",
            "id": 22,
            "rationale": null,
            "role_archetype": null,
            "slug": "video-codec-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 4,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Microservices and Distributed Systems",
          "id": 9,
          "rationale": "Architectural patterns for decomposed backend systems and the operational concerns they introduce. Covers service boundaries, consistency tradeoffs, retries, circuit breakers, and distributed coordination.",
          "slug": "microservices-and-distributed-systems",
          "source": "db"
        },
        "dimension_id": 9,
        "input_skill": "Microservices",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 41,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "Distributed Systems",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          },
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1369,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Performance and Scalability Tuning",
          "id": 11,
          "rationale": "Techniques for improving throughput, latency, and resource efficiency in PHP backend services. This includes profiling, query optimization, concurrency limits, memory use, and bottleneck analysis.",
          "slug": "performance-and-scalability-tuning",
          "source": "db"
        },
        "dimension_id": 11,
        "input_skill": "Distributed Systems",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1369,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 179,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Distributed Systems",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1369,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 0
  },
  "planner_output": null,
  "run_id": "cd93fe14-5232-4f4a-9142-89d77f31c0a0"
}

LLM Calls

Every model call made for this run, in pipeline order. Click a card to see the model's response.

Loading…