← Back to history

Pipeline run

c2572c5b-9053-41b1-b0ec-8b73981437bd

Pipeline LLM cost (USD)
API 1: $0.0052 API 2: $0.3680 API 3: $0.0000 Total: $0.3732

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description
Nature of work · Architecture & AI Platform Delivery
Own architecture and end-to-end delivery of scalable AI apps: turn business needs into Python/FastAPI/Django solutions, build and ship LLM pipelines (RAG, agents, guardrails), and run them on AWS/Azure/Databricks with Terraform, Docker, Kubernetes, and CI/CD.
""Take ownership of architecture design and development of scalable and distributed software systems.""
Tech stack maturity
Modern Cloud Native
The stack centers on cloud platforms, containers, CI/CD, Kubernetes, Terraform/CloudFormation, and modern AI application patterns like RAG, agentic workflows, and vector databases.
AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)
3.20 / 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): LangChain, Bedrock, DSPy
Models / concepts (×3): Anthropic, OpenAI, RAG, vector search, hybrid search, LLM, prompt engineering, agentic, guardrails, AI, GenAI
Evidence — skills matched in JD (42)
Python FastAPI Django AWS Azure Databricks Unity Catalog Terraform CloudFormation RAG Agentic workflows Vector DB Hybrid Search Prompt engineering OpenAI Anthropic AWS Bedrock LangChain DSPy Docker Kubernetes Git Agile DevOps CI/CD +17
Skill cluster (14 dimension groups, role-scoped)
Cloud Platforms
S3 ACR
Cloud Platforms for AI Deployment
AWS Azure
LLM Operations and Orchestration
LangChain DSPy
Web Application Frameworks
FastAPI Django
CI/CD Pipeline Platforms
DevOps
Caching and State Management
Redis
Containerization and Image Builds
Docker
Infrastructure as Code
Terraform
Kubernetes for ML Workloads
Kubernetes
Meta-Frameworks & SSR
Next.js
Python Programming
Python
RAG Architectures
Hybrid Search
React Component Architecture
React
Cross-cutting / unaligned
Databricks Unity Catalog CloudFormation RAG Agentic workflows Vector DB Prompt engineering OpenAI Anthropic AWS Bedrock Git Agile CI/CD Tailwind CSS Redshift RDS Vector Search Azure DevOps Scrum IAM Monitoring Load Balancing Autoscaling ECR AKS
Show KRA description ↓
Take ownership of architecture design and development of scalable and distributed software systems. Translate business to technical requirements Own technical execution, ensuring code quality, adherence to deadlines, and efficient resource allocation Data driven decision making skills with focus on achieving product goals Design, develop and deploy LLM based pipelines involving patterns like RAG, Agentic workflows, Responsible for the complete software development lifecycle, including requirements analysis, design, coding, testing, and deployment. Utilize AWS services/ Azure services like IAM, Monitoring, Load Balancing, Autoscaling, Database, Networking, storage, ECR, AKS, ACR etc. Utilize Databricks capabilities, esp. Unity Catalog and be able to architect the governance layer from data all-the-way to the AI model output Design, develop and deploy prompt and response guardrails to enable responsible AI requirements Implement DevOps practices using tools like Docker, Kubernetes to ensure continuous integration and delivery. Develop DevOps scripts for automation and monitoring. Collaborate with cross-functional teams, conduct code reviews, and provide guidance on software design and best practices. Bachelor’s degree in computer science, Information Technology, or a related field (or equivalent work experience). Strong coding skills with proficiency in Python Experience with API frameworks both stateless and stateful such as Fast API, Django Proficient in cloud platforms, specifically AWS, Databricks and Azure Proficient in Infra-as-Code, esp. focused on developing Terraform scripts and Cloudformation Knowledge and hands-on experience with front-end development (React JS, Next JS, Tailwind CSS) preferred Strong experience in LLM patterns like RAG, Vector DB, Hybrid Search, Agent development, Agentic workflows, prompt engineering, etc. Strong experience with LLM APIs (Open AI, Anthropic, AWS Bedrock), SDKs (Langchain, DSPy) Hands-on experience with DevOps tools including Docker, Kubernetes, and AWS services (Redshift, RDS, S3). Hands-on experience with Databricks solutions including Unity Catalog. Experience in production deployments involving thousands of users, esp with capabilities like Redis, Vector Search, etc. Strong understanding of scalable application design principles and experience with security best practices and compliance with privacy regulations. Good knowledge of software engineering practices like version control (GIT), DevOps (Azure DevOps preferred) and Agile or Scrum. Strong communication skills, with the ability to effectively convey complex technical concepts to a diverse audience. Experience of SDLC and best practices while development Experience with Agile methodology for continuous product development and delivery

Signals

Skill devops-engineer
0.19
Alias ai-engineer
1.00
KRA ai-compliance-officer
0.49

Post-classification

Centroidupdated · n=2
Alias collision log#10
New-role queue
New skills captured22
New KRA capturedyes

Captured for admin review

FastAPI primary AI Engineer pending
Databricks primary AI Engineer pending
Unity Catalog primary AI Engineer pending
Agentic workflows primary AI Engineer pending
Vector DB primary AI Engineer pending
Hybrid Search primary AI Engineer pending
Prompt engineering primary AI Engineer pending
AWS Bedrock primary AI Engineer pending
DSPy primary AI Engineer pending
Redshift AI Engineer pending
RDS AI Engineer pending
S3 AI Engineer pending
Vector Search AI Engineer pending
Azure DevOps AI Engineer pending
Scrum AI Engineer pending
DevOps primary AI Engineer pending
IAM AI Engineer pending
Monitoring AI Engineer pending
Load Balancing AI Engineer pending
ECR AI Engineer pending
AKS AI Engineer pending
ACR AI Engineer pending
R&R fragment (sim 0.00) AI Engineer pending

Take ownership of architecture design and development of scalable and distributed software systems. Translate business to technical requirements Own technical execution, ensuring code quality, adheren…

Status: completed Created: 2026-05-18T23:18:02.887611Z Updated: 2026-05-18T23:21:33.361557Z API 3 duration: 89562 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

AI Engineer

CASE D

slug: ai-engineer · id: 13 · source: db

The primary skills indicate a strong emphasis on AI technologies and cloud-based solutions.

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

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

Job description

About the job
Below are details of open role for AI Engineer.

Experience: 3+ years

Budget: 1.2-1.3 LPM

Location: Onsite (Noida, Pune, Bangalore)

We are seeking an AI Engineer with 3+ experience in LLM/GenAI/Agentic solution development,. The ideal candidate will have strong experience working with Python, LLM solution patterns and tools (RAG, Vector DB, Agentic workflows, etc.) cloud platforms (AWS preferred, Databricks and Azure works as well), and DevOps tools. They will be responsible for designing and developing scalable LLM/Agentic solutions, architecture design, and ensuring the performance and reliability of our systems.

What They Will Do

 Take ownership of architecture design and development of scalable and distributed software systems.
 Translate business to technical requirements
 Own technical execution, ensuring code quality, adherence to deadlines, and efficient resource allocation
 Data driven decision making skills with focus on achieving product goals
 Design, develop and deploy LLM based pipelines involving patterns like RAG, Agentic workflows,
 Responsible for the complete software development lifecycle, including requirements analysis, design, coding, testing, and deployment.
 Utilize AWS services/ Azure services like IAM, Monitoring, Load Balancing, Autoscaling, Database, Networking, storage, ECR, AKS, ACR etc.
 Utilize Databricks capabilities, esp. Unity Catalog and be able to architect the governance layer from data all-the-way to the AI model output
 Design, develop and deploy prompt and response guardrails to enable responsible AI requirements
 Implement DevOps practices using tools like Docker, Kubernetes to ensure continuous integration and delivery. Develop DevOps scripts for automation and monitoring.
 Collaborate with cross-functional teams, conduct code reviews, and provide guidance on software design and best practices.

What They Will Bring

 Bachelor’s degree in computer science, Information Technology, or a related field (or equivalent work experience).
 Strong coding skills with proficiency in Python
 Experience with API frameworks both stateless and stateful such as Fast API, Django
 Proficient in cloud platforms, specifically AWS, Databricks and Azure
 Proficient in Infra-as-Code, esp. focused on developing Terraform scripts and Cloudformation
 Knowledge and hands-on experience with front-end development (React JS, Next JS, Tailwind CSS) preferred
 Strong experience in LLM patterns like RAG, Vector DB, Hybrid Search, Agent development, Agentic workflows, prompt engineering, etc.
 Strong experience with LLM APIs (Open AI, Anthropic, AWS Bedrock), SDKs (Langchain, DSPy)
 Hands-on experience with DevOps tools including Docker, Kubernetes, and AWS services (Redshift, RDS, S3).
 Hands-on experience with Databricks solutions including Unity Catalog.
 Experience in production deployments involving thousands of users, esp with capabilities like Redis, Vector Search, etc.
 Strong understanding of scalable application design principles and experience with security best practices and compliance with privacy regulations.
 Good knowledge of software engineering practices like version control (GIT), DevOps (Azure DevOps preferred) and Agile or Scrum.
 Strong communication skills, with the ability to effectively convey complex technical concepts to a diverse audience.
 Experience of SDLC and best practices while development
 Experience with Agile methodology for continuous product development and delivery

Skills: azure,devops,code,api,design

Skills from this JD

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

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
416
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

  • Programming Languages and Scripting Catalog dimension db id 59

    Library dimension (catalog)

    Roles linked in library: Cybersecurity 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

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
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)
FastAPI Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.91

FastAPI appears in many Python backend job postings and is a common choice in modern API stacks; GitHub usage and ecosystem activity remain strong, with no vendor sunset or replacement trend.

Vendor & license

Sebastián Ramírez ·mit ·since 2018 (0.95)

Context keywords
Starlette Pydantic async uvicorn RESTful OpenAPI dependency injection middleware JSON WebSocket OAuth2 CORS data validation API documentation type hints
Ambiguity low

FastAPI is a specific Python web framework; typical JDs won’t confuse it with other catalog frameworks.

Versioning

Not versioned

Type assignment

Framework ·web_framework confidence 0.98

FastAPI is a framework because developers build applications inside it and it provides the application structure and request handling rather than being a standalone library or tool.

Derived legacy fields
Category
Framework
Sub-category
web_framework
Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Python Web API Frameworks

    Pipeline tentative id

    Frameworks used to build HTTP APIs and backend services in Python. FastAPI belongs here because it is a Python-first framework for defining routes, request/response models, validation, and API documentation.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Django Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Django id=9 · django

Aliases — catalog

  • Django (CANONICAL) primary
  • Django 1 (VERSION)
  • Django 1.x (VERSION)
  • Django 2 (VERSION)
  • Django 2.x (VERSION)
  • Django 3 (VERSION)
  • Django 3.x (VERSION)
  • Django 4 (VERSION)
  • Django 4.x (VERSION)
  • Django 5 (VERSION)
  • Django 5.x (VERSION)
  • Django1 (VERSION)
  • Django2 (VERSION)
  • Django3 (VERSION)
  • Django4 (VERSION)
  • Django5 (VERSION)
  • django 2 (VERSION)
  • django 2.x (VERSION)
  • django 3 (VERSION)
  • django 3.x (VERSION)
  • django 4 (VERSION)
  • django 4.x (VERSION)
  • django 5 (VERSION)
  • django 5.0 (VERSION)
  • django 5.x (VERSION)
  • django2 (VERSION)
  • django2.x (VERSION)
  • django3 (VERSION)
  • django3.x (VERSION)
  • django4 (VERSION)
  • django4.x (VERSION)
  • django5 (VERSION)
  • django5.0 (VERSION)
  • django5.x (VERSION)

Context tags (catalog)

Celery Django REST Framework Django Signals Jinja2 MVT ORM PostgreSQL QuerySet REST URL routing admin interface admin site authentication celery csrf deployment forms gunicorn middleware migrations models pytest querysets settings signals static files templates views

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Web Framework
Vendor
Django Software Foundation
License
bsd
Year introduced
2005
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
5

Maturity reasoning: Django appears in many backend web job descriptions and remains a standard Python web framework; its GitHub ecosystem and long-term LTS releases show sustained market demand.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
35
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Web Application Frameworks Catalog dimension db id 2

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: AWS id=187 · aws

Aliases — catalog

  • AWS (CANONICAL) primary

Context tags (catalog)

API Gateway AWS CLI Auto Scaling CloudFormation CloudFront CloudTrail CloudWatch Cognito DynamoDB EC2 ECS EKS Elastic Beanstalk Elastic Load Balancing IAM KMS Lambda RDS Route 53 S3 SNS SQS Serverless VPC

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Cloud Platform
Vendor
Amazon
License
other_open
Year introduced
2006
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: AWS is a hiring-pipeline staple: it appears in a large share of cloud/DevOps job descriptions and dominates public cloud market share, with broad certification and vendor ecosystem support.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
46
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

  • Cloud Provider Platforms Catalog dimension db id 131

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Cloud Security Posture Tools Catalog dimension db id 64

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

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)
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Azure id=188 · azure

Aliases — catalog

  • Azure (CANONICAL) primary

Context tags (catalog)

AKS ARM templates App Service Azure AD Azure Active Directory Azure App Service Azure Blob Azure Blob Storage Azure Cognitive Services Azure Cosmos DB Azure DevOps Azure DevTest Labs Azure Functions Azure Kubernetes Service Azure Logic Apps Azure Monitor Azure Networking Azure Resource Manager Azure SQL Azure SQL Database Azure Security Center Azure Storage Azure Storage Explorer Azure Virtual Machines Bicep Blob Storage Cloud Services Cosmos DB Entra ID Functions Infrastructure as Code Key Vault Log Analytics Logic Apps Resource Groups Serverless Computing Service Bus Storage Account Terraform Virtual Machines

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Cloud Platform
Vendor
Microsoft
License
proprietary
Year introduced
2010
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Azure is broadly adopted and frequently appears in cloud/platform job descriptions alongside AWS and GCP; Microsoft’s ongoing enterprise investment and Azure certification demand signal strong hiring-pipeline relevance.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
46
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

  • Cloud Provider Platforms Catalog dimension db id 131

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Cloud Security Posture Tools Catalog dimension db id 64

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

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)
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Databricks Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Databricks appears frequently in data engineering and analytics job postings, especially alongside Spark, Delta Lake, and lakehouse stacks; strong vendor adoption and broad enterprise usage signal mainstream demand.

Vendor & license

Databricks, Inc. ·other_open ·since 2013 (0.95)

Context keywords
Spark Delta Lake MLflow notebooks data pipelines collaborative workspace SQL Analytics data lakes Apache Spark data engineering machine learning data visualization job scheduling Databricks Runtime cloud integration real-time analytics
Ambiguity low

“Databricks” is a specific vendor/platform name; unlikely to be confused with other distinct skills in typical JDs.

Versioning

Not versioned

Type assignment

Platform ·data_analytics_platform confidence 0.97

By the Platform vs Tool rule, Databricks is a hosted multi-tenant environment with APIs and managed services rather than software you run yourself.

Derived legacy fields
Category
Platform
Sub-category
data_analytics_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Lakehouse Data Platform

    Pipeline tentative id

    Databricks is a unified lakehouse platform for data engineering, analytics, and machine learning workloads. It belongs here because the skill refers to operating and building on the Databricks environment rather than a single language or algorithm.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unity Catalog Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.84

Appears increasingly in Databricks and data-governance job postings, but JD volume is still far below core platforms like AWS or PostgreSQL; adoption is growing with Unity Catalog positioned as Databricks’ unified governance layer.

Vendor & license

Databricks ·unknown ·since 2021 (0.85)

Context keywords
data governance metadata management data lineage access control data catalog audit logs data quality schema enforcement collaboration data privacy role-based access data classification data sharing data discovery compliance
Ambiguity low

“Unity Catalog” is a specific data governance/lineage platform name; unlikely to be confused with other catalog-like skills in typical JDs.

Versioning

Not versioned

Type assignment

Platform ·data_governance_platform confidence 0.90

By the Platform vs Tool rule, Unity Catalog is a hosted, multi-tenant managed governance layer with APIs rather than software you run yourself, so it fits Platform.

Derived legacy fields
Category
Platform
Sub-category
data_governance_platform
Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Data Lineage and Metadata Catalog dimension db id 28

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Data Lineage and Metadata Catalog dimension db id 28

    Library dimension (catalog)

    Roles linked in library: Data Engineer

Locked dimensions (v3 placement)

  • Data Lineage and Metadata

    Reuses catalog slug

    Cataloging, documenting, and tracing how data assets are organized, governed, and discovered across systems. Unity Catalog belongs here because it is a metadata and governance layer for tables, views, files, permissions, and lineage in the Databricks ecosystem.

  • Databricks Data Governance

    Pipeline tentative id

    Governance features specific to Databricks for controlling access, organizing data assets, and managing cross-workspace metadata. This is a reasonable fit when Unity Catalog is used as the primary governance plane rather than just generic metadata tooling.

  • Data Lineage and Metadata

    Reuses catalog slug

    Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Data Lineage and Metadata
data-lineage-and-metadata
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Terraform Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Terraform id=286 · terraform

Aliases — catalog

  • Terraform (CANONICAL) primary

Context tags (catalog)

AWS Azure GCP HCL IaC Terraform Cloud Terraform Enterprise Terraform Registry Terragrunt apply backend destroy infrastructure automation modules outputs plan providers provisioning remote backends remote state resource blocks resource management state file state management terraform apply terraform plan variables version control workspaces

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Infrastructure As Code Tool
Vendor
HashiCorp
License
mpl
Year introduced
2014
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: Terraform is broadly listed in DevOps/SRE/cloud JDs and remains a standard IaC tool across AWS/Azure/GCP; HashiCorp’s ecosystem and widespread GitHub usage signal strong market adoption.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
191
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Infrastructure as Code for ML Catalog dimension db id 57

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Infrastructure as Code for ML
infrastructure-as-code-for-ml
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CloudFormation Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CloudFormation id=837 · cloudformation

Aliases — catalog

  • CloudFormation (CANONICAL) primary

Context tags (catalog)

AWS AWS CLI CloudFormation Designer JSON YAML change set deployment drift detection infrastructure as code nested stacks outputs parameters resource stack template

Stored enrichment (catalog DB)

Category
Service
Sub-category
Infrastructure As Code Service
Vendor
Amazon Web Services
License
proprietary
Year introduced
2013
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: AWS CloudFormation appears in many cloud/IaC job descriptions and remains a standard AWS-native infrastructure-as-code option, alongside Terraform in hiring pipelines.

Skill profile (library / DB)

Skill nature
CLOUD_SERVICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
11
Sub-category id
181
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React id=610 · react

Aliases — catalog

  • React (CANONICAL) primary
  • React 0.13 (VERSION)
  • React 0.14 (VERSION)
  • React 15 (VERSION)
  • React 15.x (VERSION)
  • React 16 (VERSION)
  • React 16.x (VERSION)
  • React 17 (VERSION)
  • React 17.x (VERSION)
  • React 18 (VERSION)
  • React 18.x (VERSION)
  • React 19 (VERSION)
  • React v15 (VERSION)
  • React v16 (VERSION)
  • React v17 (VERSION)
  • React v18 (VERSION)
  • React v19 (VERSION)
  • ReactJS 18 (VERSION)
  • react 15 (VERSION)
  • react 16 (VERSION)
  • react 17 (VERSION)
  • react 18 (VERSION)
  • react 19 (VERSION)
  • react15 (VERSION)
  • react16 (VERSION)
  • react17 (VERSION)
  • react18 (VERSION)
  • react19 (VERSION)
  • reactjs 18 (VERSION)

Context tags (catalog)

Babel Class Components Component Lifecycle Context API Functional Components Higher-Order Components Hooks JSX Next.js PropTypes Props React Native React Router Redux SSR State Management Styled Components Testing Library TypeScript Virtual DOM Webpack component lifecycle context API frontend hooks props state management useEffect useState virtual DOM

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Frontend Framework
Vendor
Meta
License
mit
Year introduced
2013
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
18

Maturity reasoning: React appears in high-volume frontend job postings across startups and enterprises and remains a default hiring-pipeline skill, with strong GitHub/npm usage and ecosystem activity.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
341
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer, Hybrid Mobile Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Next.js Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Next.js id=705 · next-js

Aliases — catalog

  • Next.js (CANONICAL) primary
  • Next 10 (VERSION)
  • Next 11 (VERSION)
  • Next 12 (VERSION)
  • Next 13 (VERSION)
  • Next 14 (VERSION)
  • Next 15 (VERSION)
  • Next 2 (VERSION)
  • Next 3 (VERSION)
  • Next 4 (VERSION)
  • Next 5 (VERSION)
  • Next 6 (VERSION)
  • Next 7 (VERSION)
  • Next 8 (VERSION)
  • Next 9 (VERSION)
  • Next.js 1 (VERSION)
  • Next.js 10 (VERSION)
  • Next.js 11 (VERSION)
  • Next.js 12 (VERSION)
  • Next.js 13 (VERSION)
  • Next.js 14 (VERSION)
  • Next.js 15 (VERSION)
  • Next.js 2 (VERSION)
  • Next.js 3 (VERSION)
  • Next.js 4 (VERSION)
  • Next.js 5 (VERSION)
  • Next.js 6 (VERSION)
  • Next.js 7 (VERSION)
  • Next.js 8 (VERSION)
  • Next.js 9 (VERSION)
  • next (VERSION)
  • next.js (VERSION)
  • next.js 14 (VERSION)
  • nextjs (VERSION)
  • nextjs 14 (VERSION)

Context tags (catalog)

API routes App Router CSS-in-JS Client Components ISR JAMstack Pages Router React SSG SSR Server Components Tailwind CSS TypeScript Vercel Webpack dynamic routing getServerSideProps getStaticProps headless CMS incremental static regeneration middleware server-side rendering static generation webpack

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Web Framework
Vendor
Vercel
License
mit
Year introduced
2016
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Next.js appears in many frontend/full-stack job descriptions and is a common React meta-framework for production apps; Vercel’s ecosystem and strong GitHub adoption signal broad market demand.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
35
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Meta-Frameworks & SSR Catalog dimension db id 130

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Meta-Frameworks & SSR
meta-frameworks-ssr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Tailwind CSS Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Tailwind CSS id=627 · tailwind-css

Aliases — catalog

  • Tailwind CSS (CANONICAL) primary
  • tailwind (VERSION)
  • tailwind 3 (VERSION)
  • tailwind 3.x (VERSION)
  • tailwind css (VERSION)
  • tailwind v3 (VERSION)
  • tailwindcss (VERSION)
  • tailwindcss v3 (VERSION)

Context tags (catalog)

@apply CSS Grid CSS variables CSS-in-JS JIT mode PostCSS Tailwind UI animation utilities breakpoints component classes component libraries custom themes dark mode design systems design tokens flexbox focus: grid grid layout hover states hover: media queries postcss purgeCSS purgecss responsive design responsive variants spacing scale theme customization transition effects utility classes utility-first

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Css Framework
Vendor
Tailwind Labs
License
mit
Year introduced
2017
Confidence
0.97
Version strategy
SEPARATE_ENTITY
Version tag
3

Maturity reasoning: Widely listed in frontend job descriptions and used across many production web stacks; strong GitHub adoption and ecosystem support indicate it’s a hiring-pipeline staple.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
481
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CSS Architecture and Styling Catalog dimension db id 117

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
RAG Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: RAG id=1194 · rag

Aliases — catalog

  • RAG (CANONICAL)

Context tags (catalog)

AI applications contextualization data augmentation fine-tuning generation information retrieval knowledge integration machine learning model training natural language processing prompt engineering retrieval semantic search transformer models user intent

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Retrieval Augmented Generation
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: RAG appears in many recent AI/ML job descriptions and vendor docs, but it is still not a universal baseline skill like Python or SQL; market demand is rising fast rather than fully standardized.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agentic workflows Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.84

Job postings increasingly mention agentic workflows alongside LLM orchestration and tool-use, and GitHub activity around agent frameworks has surged, but it is not yet a universal hiring staple.

Vendor & license

(0.60)

Context keywords
workflow automation process orchestration event-driven microservices business rules state management service integration user-centric design API gateways data flow real-time processing declarative programming task scheduling system interoperability adaptive systems
Ambiguity low

“Agentic workflows” is a specific architecture concept; typical JDs won’t confuse it with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Architecture ·agentic_workflow_architecture confidence 0.88

By the Architecture vs Concept rule, agentic workflows describe a system-shape/pattern for how autonomous agents are organized and interact, rather than a single knowledge unit or process.

Derived legacy fields
Category
Architecture
Sub-category
agentic_workflow_architecture
Skill nature
PATTERN
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Agentic Workflow Orchestration

    Pipeline tentative id

    Designing and coordinating multi-step AI agent processes that plan, act, observe results, and adapt toward a goal. This covers workflow patterns where an LLM-driven agent uses tools, memory, and control logic to complete tasks autonomously or semi-autonomously.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vector DB Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.89

Vector DBs are increasingly listed in AI/ML job descriptions and vendor ecosystems, but they’re not yet a universal datastore staple like PostgreSQL or AWS.

Vendor & license

Pinecone ·proprietary ·since 2020 (0.85)

Context keywords
embedding similarity search nearest neighbors Pinecone Weaviate FAISS Annoy vector search semantic search real-time analytics data indexing machine learning natural language processing high-dimensional data scalability
Ambiguity low

“Vector DB” in JDs typically refers specifically to vector databases for embeddings/search, not other datastore types.

Versioning

Not versioned

Type assignment

Datastore ·vector_database confidence 0.93

By the Datastore vs Format rule, a vector DB is a system that persists and indexes data for retrieval, so it is fundamentally a Datastore rather than a Tool or Platform.

Derived legacy fields
Category
Datastore
Sub-category
vector_database
Skill nature
TOOL
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Vector Databases and Similarity Search

    Pipeline tentative id

    Datastores optimized for storing embeddings and performing nearest-neighbor similarity search over high-dimensional vectors. Vector DB belongs here because it refers to the database layer used for retrieval, indexing, and semantic search in AI systems.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Hybrid Search Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.84

Hybrid search appears increasingly in job descriptions for RAG/search roles and is supported by major vendors like Elasticsearch and OpenSearch, but it is not yet a universal hiring staple.

Vendor & license

(0.95)

Context keywords
vector search semantic search information retrieval natural language processing machine learning ranking algorithms query expansion relevance feedback fuzzy matching data fusion indexing strategies search algorithms knowledge graphs metadata enrichment user intent
Ambiguity low

“Hybrid Search” is a specific retrieval pattern (combining lexical + vector). Typical JDs won’t confuse it with other distinct search/IR skills in the catalog.

Versioning

Not versioned

Type assignment

Concept ·search_retrieval_pattern confidence 0.92

Hybrid Search is fundamentally a named retrieval concept/pattern combining multiple search approaches, and it is not a tool, platform, or architecture under the provided disambiguation rules.

Derived legacy fields
Category
Concept
Sub-category
search_retrieval_pattern
Skill nature
CONCEPT
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Hybrid Search Retrieval

    Pipeline tentative id

    Retrieval approaches that combine lexical and semantic search signals to improve relevance. Hybrid search belongs here because it typically blends keyword matching with vector similarity, reranking, and query fusion for robust information retrieval.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Prompt engineering Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.86

Prompt engineering is increasingly listed in AI/LLM job descriptions and vendor docs, but it’s still not a universal hiring staple like Python or AWS.

Vendor & license

(0.95)

Context keywords
fine-tuning natural language processing model training user intent contextual prompts prompt design iterative testing prompt templates AI alignment feedback loops data annotation evaluation metrics prompt optimization user experience language models
Ambiguity low

“Prompt engineering” is a specific, commonly used term for LLM prompting and is unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·prompt_engineering confidence 0.93

Prompt engineering is fundamentally a way of working for crafting and iterating prompts, so by the Concept vs Methodology rule it fits Methodology rather than a tool or concept.

Derived legacy fields
Category
Methodology
Sub-category
prompt_engineering
Skill nature
METHODOLOGY
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Prompt Engineering

    Pipeline tentative id

    Designing, refining, and evaluating prompts for large language models and other generative AI systems. This includes instruction phrasing, few-shot examples, output constraints, and iterative prompt debugging to improve reliability and task performance.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
OpenAI Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: OpenAI id=1186 · openai

Aliases — catalog

  • OpenAI (CANONICAL)

Context tags (catalog)

AI ethics API ChatGPT Codex DALL-E GPT-3 data augmentation fine-tuning machine learning model training natural language processing neural networks prompt engineering reinforcement learning transformer

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Ai Platform
Vendor
OpenAI
License
other_open
Year introduced
2015
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: OpenAI appears in a growing number of job postings for LLM/app integration, but it is not yet a universal baseline skill like AWS or Python; market demand is rising alongside API adoption.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
896
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Anthropic Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Anthropic id=1188 · anthropic

Aliases — catalog

  • Anthropic (CANONICAL)

Context tags (catalog)

AI safety Claude alignment data privacy ethical AI fine-tuning human-in-the-loop machine learning model interpretability multi-modal natural language processing prompt engineering reinforcement learning scalability transformers

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Ai Model Platform
Vendor
Anthropic
License
unknown
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Anthropic/Claude is increasingly listed in AI engineer JDs and vendor docs, but it is not yet as universal as AWS/OpenAI; GitHub and job-market signals show rapid growth rather than saturation.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
898
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS Bedrock Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.86

AWS Bedrock is appearing in more job descriptions and vendor docs as teams adopt managed LLM APIs, but it is still far less common than core AWS services like EC2/S3 or Kubernetes in hiring pipelines.

Vendor & license

Amazon Web Services ·proprietary ·since 2023 (0.95)

Context keywords
foundation models generative AI machine learning SageMaker API integration data pipelines model training inference scalability cloud-native serverless architecture data security real-time analytics multi-modal deployment cost optimization
Ambiguity low

AWS Bedrock is a specific AWS foundation-model service; typical JDs distinguish it from other AWS AI services.

Versioning

Not versioned

Type assignment

Service ·foundation_model_service confidence 0.97

By the Platform vs Service rule, AWS Bedrock is a managed capability inside AWS rather than the AWS platform itself, so it is a Service.

Derived legacy fields
Category
Service
Sub-category
foundation_model_service
Skill nature
CLOUD_SERVICE
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

Locked dimensions (v3 placement)

  • Cloud Platform Services

    Reuses catalog slug

    Core managed services offered by major cloud providers for building and operating applications. AWS Bedrock fits here because it is an AWS-managed platform service used by engineers to access foundation models and related AI capabilities.

  • Cloud Platforms

    Reuses catalog slug

    Proficiency in major cloud service provider platforms and their core services.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
LangChain Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: LangChain id=240 · langchain

Aliases — catalog

  • LangChain (CANONICAL) primary

Context tags (catalog)

API integration Hugging Face LLM LLMs OpenAI RAG agents callbacks chains data augmentation deployment document loaders embeddings fine-tuning memory prompt engineering prompt templates prompts retrieval retrievers state management streaming text splitters toolkits tools vector database vector stores

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Llm Application Framework
Vendor
Harrison Chase
License
mit
Year introduced
2022
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: LangChain appears in many recent AI/LLM job postings and is widely used in app prototypes, but it’s still not a universal hiring staple like React or AWS.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
146
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • LLM Operations and Orchestration Catalog dimension db id 49

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DSPy Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.84

DSPy is appearing in more LLM engineering job descriptions and GitHub adoption is rising, but it is still far from a universal hiring staple like PyTorch or LangChain.

Vendor & license

Cohere ·apache_2 ·since 2023 (0.90)

Context keywords
data science machine learning AI models programming pipelines data preprocessing model training evaluation metrics feature engineering automated workflows predictive analytics data visualization algorithm optimization deployment real-time processing
Ambiguity low

DSPy is a specific LLM programming framework name; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Framework ·llm_programming_framework confidence 0.90

DSPy is best classified as a Framework because users build applications and LLM pipelines inside it rather than using it as standalone software.

Derived legacy fields
Category
Framework
Sub-category
llm_programming_framework
Skill nature
FRAMEWORK
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Prompt Programming Frameworks

    Pipeline tentative id

    Frameworks and libraries for building, optimizing, and evaluating LLM applications through structured prompts, modules, and programmatic prompt composition. DSPy belongs here because it is a prompt-centric framework for writing and tuning LLM pipelines rather than a general ML model library.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Docker id=61 · docker

Aliases — catalog

  • Docker (CANONICAL) primary

Context tags (catalog)

CI/CD Compose DevOps Docker Compose Docker Swarm Dockerfile Kubernetes build pipeline container container lifecycle container orchestration container registry container security containerization containers image image registry images immutable infrastructure lightweight virtualization microservices networking orchestration port mapping registry scalability service discovery swarm volume volume management

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Containerization Tool
Vendor
Docker, Inc.
License
apache_2
Year introduced
2013
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Docker is a hiring-pipeline staple: it appears in many DevOps, backend, and platform JDs, and remains a standard containerization tool alongside Kubernetes in production stacks.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
654
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Containerization and Image Builds Catalog dimension db id 152

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Deployment and Runtime Configuration Catalog dimension db id 13

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Containerization and Image Builds
containerization-and-image-builds
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Deployment and Runtime Configuration
deployment-and-runtime-configuration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kubernetes id=726 · kubernetes

Aliases — catalog

  • Kubernetes (CANONICAL) primary
  • Kubernetes 1.0+ (VERSION)
  • Kubernetes 1.x (VERSION)
  • Kubernetes v1 (VERSION)
  • k8s (VERSION)
  • kubernetes 1.x (VERSION)
  • kubernetes latest (VERSION)

Context tags (catalog)

CI/CD Cluster Autoscaler ConfigMap DaemonSet Deployment Docker Grafana Helm Ingress Istio K8s Kubelet Namespace Pod Prometheus RBAC Secret Service StatefulSet containerization deployment etcd kubectl load balancing microservices namespace orchestration persistent storage scalability service mesh

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Container Orchestration Platform
Vendor
Cloud Native Computing Foundation
License
apache_2
Year introduced
2014
Confidence
0.90
Version strategy
SEPARATE_ENTITY
Version tag
1.30

Maturity reasoning: Broadly adopted in cloud-native stacks; Kubernetes appears in a large share of DevOps/SRE job descriptions and is the default orchestration platform across major cloud vendors.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
557
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redshift Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Amazon Redshift is widely listed in data-warehouse/cloud analytics job descriptions and remains an AWS flagship service; no vendor sunset, and it’s commonly paired with Snowflake/BigQuery rather than replaced.

Vendor & license

Amazon ·proprietary ·since 2012 (0.95)

Context keywords
AWS data lake SQL ETL data modeling analytics columnar storage scalability performance tuning data migration business intelligence Redshift Spectrum cluster management query optimization data warehousing Amazon S3
Ambiguity low

“Redshift” typically refers specifically to Amazon Redshift; it’s unlikely to be confused with other distinct data-warehouse platforms in typical JDs.

Versioning

Not versioned

Type assignment

Platform ·data_warehouse_platform confidence 0.93

By the Vendor SaaS = Platform rule, Amazon Redshift is a hosted multi-tenant managed analytics environment with APIs rather than software you run yourself, so it fits Platform.

Derived legacy fields
Category
Platform
Sub-category
data_warehouse_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

Locked dimensions (v3 placement)

  • Cloud Data Warehousing Platforms

    Reuses catalog slug

    Managed cloud data warehouse services used for analytical storage, SQL querying, and large-scale reporting. Redshift belongs here because it is an AWS-managed warehouse platform for storing and analyzing structured data.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
RDS Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

AWS RDS is a standard managed database service and appears frequently in cloud/DevOps job descriptions alongside PostgreSQL/MySQL on AWS, indicating broad hiring-pipeline adoption.

Vendor & license

Amazon Web Services ·proprietary ·since 2009 (0.95)

Context keywords
AWS Aurora PostgreSQL MySQL SQL Server database migration scalability high availability backup and restore multi-AZ read replicas performance tuning security groups parameter groups cloudformation
Ambiguity flagged

Could be confused with: rds_aws

“RDS” is commonly used for AWS Relational Database Service; could be extracted as a specific AWS RDS skill vs a generic RDS entry.

Versioning

Not versioned

Type assignment

Service ·managed_relational_database_service confidence 0.97

By the Service vs Platform rule, RDS is a specific managed capability inside AWS rather than the whole hosted environment, so it is a Service.

Derived legacy fields
Category
Service
Sub-category
managed_relational_database_service
Skill nature
CLOUD_SERVICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

Locked dimensions (v3 placement)

  • Cloud Database Services

    Reuses catalog slug

    Managed database services offered by cloud providers for relational storage, scaling, backups, and high availability. RDS belongs here because it commonly refers to Amazon Relational Database Service, a core managed database platform in cloud engineering.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
S3 Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.98

Amazon S3 is a default cloud storage service in AWS job descriptions and architecture docs; it remains broadly adopted with no vendor sunset, and is commonly paired with S3-compatible storage rather than replaced.

Vendor & license

Amazon ·proprietary ·since 2006 (0.95)

Context keywords
AWS bucket object storage S3 Select IAM policies versioning data lifecycle multipart upload transfer acceleration CloudFormation event notifications CORS encryption static website hosting AWS CLI
Ambiguity low

“S3” in JDs typically refers unambiguously to AWS Simple Storage Service; other common meanings are rare in this context.

Versioning

Not versioned

Type assignment

Platform ·cloud_storage_platform confidence 0.90

By the Platform vs Tool rule, S3 is a hosted multi-tenant AWS environment with APIs and managed storage capabilities, so it is a Platform rather than a user-run tool or a datastore product.

Derived legacy fields
Category
Platform
Sub-category
cloud_storage_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Systems Programming Catalog dimension db id 166

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Cloud Storage Services

    Reuses catalog slug

    Managed object storage services used to store, retrieve, and serve files, datasets, backups, and application assets. S3 belongs here because it is the canonical AWS object storage service and is commonly used as foundational cloud storage infrastructure.

  • Object Storage Operations

    Pipeline tentative id

    Operational use of object storage for durable file and dataset management across applications and pipelines. This fits S3 when the emphasis is on organizing objects, controlling access, and managing storage behavior rather than broader cloud platform knowledge.

  • AWS Storage Services

    Pipeline tentative id

    AWS-specific storage primitives and managed storage offerings used to persist application data and artifacts. S3 belongs here as the primary AWS object storage service and a common integration point for AI and data workflows.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Systems Programming
d_init_02
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redis Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Redis id=31 · redis

Aliases — catalog

  • Redis (CANONICAL) primary

Context tags (catalog)

JSON serialization JSON support LRU eviction Lua scripting Redis Cluster Redis Sentinel Redis Streams TTL backup and restore cache connection pooling data persistence hashes in-memory key expiration lists performance tuning persistence pipeline pub/sub replication sentinel sharding sorted sets streams transactions

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Key Value Store
Vendor
Redis Labs
License
apache_2
Year introduced
2009
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Redis appears in many job descriptions for caching, queues, and session storage, and is a standard datastore in modern backend stacks; vendor activity and broad ecosystem support indicate strong market demand.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
3
Sub-category id
28
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Caching and State Management Catalog dimension db id 7

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Caching and State Management
caching-and-state-management
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vector Search Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.88

Vector search is increasingly listed in AI/ML and search JDs, and major vendors like Pinecone, Weaviate, and pgvector show strong adoption, but it is not yet a universal hiring staple.

Vendor & license

(0.95)

Context keywords
embedding similarity nearest neighbor semantic search ANN vector database FAISS Pinecone Milvus cosine similarity search index query vector dimensionality reduction vector space model retrieval augmentation
Ambiguity low

“Vector Search” is a specific retrieval concept (embeddings + similarity) and is unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Concept ·vector_search confidence 0.78

Vector Search is best treated as a Concept because it names a retrieval approach/technique rather than a specific product, runtime, or system you operate.

Derived legacy fields
Category
Concept
Sub-category
vector_search
Skill nature
CONCEPT
Volatility
EMERGING
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Vector Search Systems

    Pipeline tentative id

    Systems and techniques for indexing, storing, and querying embeddings by semantic similarity. Vector Search belongs here because it is the core retrieval mechanism behind embedding-based search, recommendation, and RAG pipelines.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Git Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Git id=1002 · git

Aliases — catalog

  • Git (CANONICAL)

Context tags (catalog)

CI/CD GitHub GitLab branching checkout clone commit fork merging pull request rebase remote repository stash versioning

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Version Control Tool
Vendor
Linus Torvalds
License
gpl_v2
Year introduced
2005
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Git is a hiring-pipeline staple: it appears in the vast majority of software engineering job descriptions and is the default VCS on GitHub/GitLab/Bitbucket.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
730
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure DevOps Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Azure DevOps appears in many enterprise job descriptions for CI/CD, boards, and repos, and Microsoft continues active product support and updates; it remains a common hiring-pipeline skill alongside GitHub Actions/Jenkins.

Vendor & license

Microsoft ·proprietary ·since 2018 (0.95)

Context keywords
Azure Pipelines Terraform GitHub Actions Docker Kubernetes Agile Continuous Integration Continuous Deployment Infrastructure as Code Release Management Monitoring Version Control Service Hooks Work Items Build Agents
Ambiguity low

“Azure DevOps” is a specific Microsoft DevOps suite; typical JDs won’t confuse it with other CI/CD platforms like Jenkins or GitHub Actions.

Versioning

Not versioned

Type assignment

Platform ·devops_platform confidence 0.93

By the Platform vs Tool rule, Azure DevOps is a hosted multi-tenant environment with APIs and managed services rather than software you run yourself.

Derived legacy fields
Category
Platform
Sub-category
devops_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

Locked dimensions (v3 placement)

  • CI/CD Pipeline Platforms

    Reuses catalog slug

    Systems used to define, run, and maintain automated build and deployment workflows. Azure DevOps belongs here because it provides pipeline authoring, build agents, release automation, and repo-integrated delivery tooling.

  • CI/CD Pipeline Platforms

    Reuses catalog slug

    Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agile Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Agile id=520 · agile

Aliases — catalog

  • Agile (CANONICAL) primary

Context tags (catalog)

Kanban SAFe Scrum backlog backlog grooming burndown burndown chart continuous delivery continuous improvement cross-functional daily standup epics incremental development iteration iteration planning lean product backlog product owner retrospective sprint sprint planning stand-up story points user stories velocity

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Agile
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Agile appears in a large share of software job descriptions and is a standard hiring-pipeline requirement; Scrum/Kanban are commonly listed alongside it, showing broad market adoption.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
367
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Scrum appears in a large share of software PM/Agile job descriptions and is a standard certification/topic in hiring pipelines, indicating broad market adoption.

Vendor & license

(0.95)

Context keywords
sprint backlog scrum master product owner daily standup retrospective burndown chart user stories increment velocity Kanban Agile story points definition of done release planning
Ambiguity low

“Scrum” is a specific Agile framework; typical JDs distinguish it from other methodologies like Kanban or XP.

Versioning

Not versioned

Type assignment

Methodology ·agile_project_management_methodology confidence 0.99

By the Concept vs Methodology rule, Scrum is a way of working and managing work rather than a knowledge unit or system shape, so it is a Methodology.

Derived legacy fields
Category
Methodology
Sub-category
agile_project_management_methodology
Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Agile Scrum Practices

    Pipeline tentative id

    Scrum is an agile delivery framework for planning, coordinating, and inspecting work in iterative increments. It belongs here because it defines team ceremonies, roles, and backlog-driven execution rather than a technical implementation skill.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

DevOps appears in a large share of software and platform engineering job descriptions, often alongside CI/CD, Kubernetes, and cloud tooling; it is a standard hiring-pipeline keyword rather than a niche specialty.

Vendor & license

(0.95)

Context keywords
CI/CD Docker Kubernetes Terraform Ansible Jenkins GitOps Microservices Infrastructure as Code Monitoring Agile Continuous Integration Continuous Deployment Cloud-native SRE Automation
Ambiguity low

“DevOps” is a widely used, distinct methodology term; typical JDs won’t confuse it with other specific catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·devops_methodology confidence 0.97

DevOps is fundamentally a way of working that combines development and operations practices, so by the Concept vs Methodology rule it is a Methodology.

Derived legacy fields
Category
Methodology
Sub-category
devops_methodology
Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

Locked dimensions (v3 placement)

  • CI/CD Pipeline Platforms

    Reuses catalog slug

    Systems used to define, run, and maintain automated build, test, and deployment workflows. DevOps work commonly centers on these delivery pipelines and the tooling that operationalizes software changes.

  • Infrastructure as Code

    Reuses catalog slug

    Declarative provisioning and environment definition tools used to codify cloud infrastructure and repeatable platform setup. DevOps often includes IaC because it automates the environments that delivery pipelines deploy into.

  • Deployment and Release Patterns

    Reuses catalog slug

    Patterns for promoting software safely across environments, including rollout, rollback, gating, and release coordination. DevOps frequently includes these operational release practices because they govern how changes reach production.

  • Infrastructure as Code

    Reuses catalog slug

    Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.

  • CI/CD Pipeline Platforms

    Reuses catalog slug

    Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.

  • Deployment and Release Patterns

    Reuses catalog slug

    Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Infrastructure as Code
infrastructure-as-code
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Deployment and Release Patterns
deployment-and-release-patterns
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CI/CD id=1190 · ci-cd

Aliases — catalog

  • CI/CD (CANONICAL)

Context tags (catalog)

Ansible CircleCI Docker GitLab CI Jenkins Kubernetes Terraform Travis CI automated testing build automation continuous deployment continuous integration deployment pipelines monitoring version control

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Ci Cd Process
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: CI/CD appears in a large share of software engineering JDs and is a standard requirement across DevOps, platform, and backend roles; major vendors like GitHub, GitLab, and AWS all center product roadmaps on CI/CD pipelines.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
900
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD for Machine Learning Catalog dimension db id 56

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
IAM Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

IAM is a standard cloud/security platform skill; it appears routinely in AWS/Azure/GCP job descriptions and is a core control in vendor docs and compliance frameworks, indicating broad hiring demand.

Vendor & license

Amazon Web Services ·proprietary ·since 2011 (0.90)

Context keywords
SAML OAuth OpenID Connect MFA RBAC ABAC SSO directory services identity federation user provisioning access control audit logs policy management security tokens IAM governance
Ambiguity low

IAM (Identity and Access Management) is a standard, specific security domain; typical JDs won’t confuse it with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·identity_and_access_management_platform confidence 0.90

By the Vendor SaaS = Platform rule, IAM here is best treated as a hosted identity and access management environment with APIs rather than a local tool, since it denotes the managed access-control platform capability.

Derived legacy fields
Category
Platform
Sub-category
identity_and_access_management_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Identity and Access Management

    Pipeline tentative id

    Controls for defining identities, roles, permissions, and access policies across systems. IAM belongs here because it is the core discipline for authenticating principals and authorizing what they can do.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Monitoring Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Monitoring is a standard requirement in most SRE/DevOps job descriptions and is bundled into major platforms like AWS CloudWatch, Datadog, and Prometheus, indicating broad market adoption.

Vendor & license

(1.00)

Context keywords
Prometheus Grafana ELK Stack alerting metrics logging tracing SLO SLI observability incident response health checks anomaly detection dashboards monitoring as code
Ambiguity low

“Monitoring” in observability/incident triage is a common, specific concept and is unlikely to be confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Concept ·observability_monitoring confidence 0.88

Monitoring is fundamentally a knowledge unit about observing system health and behavior, so it fits the Concept category rather than a Tool or Platform under the provided rules.

Derived legacy fields
Category
Concept
Sub-category
observability_monitoring
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Observability and Incident Triage Catalog dimension db id 155

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Observability and Incident Triage Catalog dimension db id 155

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

Locked dimensions (v3 placement)

  • Observability and Incident Triage

    Reuses catalog slug

    Telemetry, alerting, and troubleshooting practices used to detect and diagnose unhealthy systems. Monitoring belongs here because it is the core activity of watching metrics, logs, and traces to spot issues and drive response.

  • Observability and Incident Triage

    Reuses catalog slug

    Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Observability and Incident Triage
observability-and-incident-triage
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Load Balancing Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Load balancing is a standard architecture requirement in cloud and infra JDs, commonly listed alongside AWS, Kubernetes, and NGINX/HAProxy for production traffic distribution.

Vendor & license

(0.95)

Context keywords
HAProxy Nginx F5 traffic management round robin failover sticky sessions DNS load balancing application delivery scalability high availability reverse proxy session persistence distributed systems cloud load balancing
Ambiguity low

“Load Balancing” in JDs typically refers to distributing traffic across instances; it’s distinct from other architecture skills in the catalog.

Versioning

Not versioned

Type assignment

Architecture ·traffic_distribution_architecture confidence 0.88

Load balancing is fundamentally a system-shape pattern for distributing traffic across multiple instances, so it fits the Architecture category rather than a tool or concept.

Derived legacy fields
Category
Architecture
Sub-category
traffic_distribution_architecture
Skill nature
PATTERN
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

Locked dimensions (v3 placement)

  • Deployment and Release Patterns

    Reuses catalog slug

    Patterns for distributing traffic safely across application instances and environments during rollout and steady-state operation. Load balancing belongs here when it is used to spread requests, improve availability, and support controlled release behavior.

  • Deployment and Release Patterns

    Reuses catalog slug

    Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Deployment and Release Patterns
deployment-and-release-patterns
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Autoscaling Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: autoscaling id=858 · autoscaling

Aliases — catalog

  • autoscaling (CANONICAL) primary

Context tags (catalog)

AWS Auto Scaling Kubernetes capacity planning cloud infrastructure container orchestration cost efficiency dynamic scaling elasticity horizontal scaling load balancing performance tuning resource optimization scaling policies serverless architecture vertical scaling

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Scaling Concept
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: Autoscaling is a standard cloud/Kubernetes capability and appears routinely in AWS, GCP, Azure, and Kubernetes job descriptions, with vendor docs and managed services built around it.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ECR Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.92

Amazon ECR is a standard AWS container registry; it appears frequently in cloud/platform job descriptions and is the default registry in many Kubernetes/ECS deployment stacks.

Vendor & license

Amazon ·proprietary ·since 2015 (0.95)

Context keywords
Docker containerization Kubernetes image repository CI/CD artifact management registry authentication Helm microservices cloud-native DevOps container orchestration security scanning versioning API integration
Ambiguity low

ECR is a specific, commonly referenced AWS service name (Elastic Container Registry), unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·container_registry_platform confidence 0.90

By the Platform vs Tool rule, ECR is a hosted, multi-tenant AWS-managed registry service consumed via APIs rather than software you run yourself.

Derived legacy fields
Category
Platform
Sub-category
container_registry_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

Locked dimensions (v3 placement)

  • Cloud Container Registry Services

    Reuses catalog slug

    Managed registry services used to store, version, scan, and distribute container images and related artifacts. ECR belongs here because it is AWS's container registry used by build and deployment workflows.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AKS Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.92

AKS appears frequently in cloud/Kubernetes job descriptions and Microsoft actively markets it as a core Azure service, indicating broad enterprise adoption rather than niche use.

Vendor & license

Microsoft ·other_open ·since 2018 (0.90)

Context keywords
Azure Kubernetes containerization Helm kubectl microservices CI/CD DevOps container registry service mesh monitoring scalability load balancing network policies persistent storage
Ambiguity low

AKS is a specific acronym for Azure Kubernetes Service; typical JDs won’t confuse it with other Kubernetes platforms.

Versioning

Not versioned

Type assignment

Platform ·kubernetes_platform confidence 0.97

AKS is a vendor-hosted managed Kubernetes environment with APIs and multi-tenancy, so by the Platform vs Tool rule it is a Platform rather than software you run yourself.

Derived legacy fields
Category
Platform
Sub-category
kubernetes_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

Locked dimensions (v3 placement)

  • Container Orchestration Platforms

    Reuses catalog slug

    Platforms that schedule, scale, and manage containerized workloads across clusters and environments. AKS belongs here because it is Azure's managed Kubernetes service used to run and operate container workloads.

  • Container Orchestration Platforms

    Reuses catalog slug

    Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Container Orchestration Platforms
container-orchestration-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ACR Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.86

Azure Container Registry (ACR) is a standard Azure service commonly listed in cloud/container DevOps job descriptions alongside AKS and Docker; Microsoft continues active support and docs, indicating broad market adoption.

Vendor & license

Microsoft ·other_open ·since 2017 (0.90)

Context keywords
Docker Kubernetes containerization CI/CD image repository artifact management Azure DevOps Helm microservices registry authentication cloud-native DevOps container orchestration scalability versioning
Ambiguity flagged

Could be confused with: acr_azure_container_registry, acr_aws_cloudfront_origin_request_control

ACR is a common acronym; in JDs it may refer to Azure Container Registry or other ACR-related services, not uniquely this platform.

Versioning

Not versioned

Type assignment

Platform ·container_registry_platform confidence 0.88

By the Platform vs Tool rule, ACR (Azure Container Registry) is a hosted, multi-tenant Azure service with APIs rather than software you run yourself, so it fits Platform.

Derived legacy fields
Category
Platform
Sub-category
container_registry_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer

Locked dimensions (v3 placement)

  • Azure Container Registry

    Pipeline tentative id

    Azure Container Registry (ACR) is the managed registry used to store, version, and distribute container images and related artifacts in Azure-centric delivery flows. It belongs here because ACR is the specific platform skill, not the broader container orchestration or security domains.

  • Cloud Platforms

    Reuses catalog slug

    Cloud platforms cover major provider ecosystems and their managed services used to build and operate applications. ACR fits here as an Azure-managed service within the broader cloud platform surface.

  • Cloud Platforms

    Reuses catalog slug

    Proficiency in major cloud service provider platforms and their core services.

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cloud Platforms
cloud-platforms
New skill saved · 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
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)
Django in_db
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure in_db
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure in_db
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Terraform in_db
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Terraform in_db
Infrastructure as Code for ML
infrastructure-as-code-for-ml
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CloudFormation in_db
Infrastructure as Code
infrastructure-as-code
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Next.js in_db
Meta-Frameworks & SSR
meta-frameworks-ssr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Tailwind CSS in_db
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
RAG in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
OpenAI in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Anthropic in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
LangChain in_db
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Containerization and Image Builds
containerization-and-image-builds
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Deployment and Runtime Configuration
deployment-and-runtime-configuration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes in_db
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redis in_db
Caching and State Management
caching-and-state-management
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Git in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agile in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Autoscaling in_db
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
FastAPI in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Databricks in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unity Catalog in_db
Data Lineage and Metadata
data-lineage-and-metadata
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unity Catalog in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agentic workflows in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vector DB in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Hybrid Search in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Prompt engineering in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS Bedrock in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DSPy in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redshift in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
RDS in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
S3 in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
S3 in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
S3 in_db
Systems Programming
d_init_02
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vector Search in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Azure DevOps in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps in_db
Infrastructure as Code
infrastructure-as-code
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DevOps in_db
Deployment and Release Patterns
deployment-and-release-patterns
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
IAM in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Monitoring in_db
Observability and Incident Triage
observability-and-incident-triage
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Load Balancing in_db
Deployment and Release Patterns
deployment-and-release-patterns
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ECR in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AKS in_db
Container Orchestration Platforms
container-orchestration-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ACR in_db
React Frontend Development
d_init_01
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ACR in_db
Cloud Platforms
cloud-platforms
New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_added FastAPI 1201
canonical_skill_added Databricks 1202
canonical_skill_added Unity Catalog 1203
canonical_skill_added Agentic workflows 1204
canonical_skill_added Vector DB 1205
canonical_skill_added Hybrid Search 1206
canonical_skill_added Prompt engineering 1207
canonical_skill_added AWS Bedrock 1208
canonical_skill_added DSPy 1209
canonical_skill_added Redshift 1210
canonical_skill_added RDS 1211
canonical_skill_added S3 1212
canonical_skill_added Vector Search 1213
canonical_skill_added Azure DevOps 1214
canonical_skill_added Scrum 1215
canonical_skill_added DevOps 1216
canonical_skill_added IAM 1217
canonical_skill_added Monitoring 1218
canonical_skill_added Load Balancing 1219
canonical_skill_added ECR 1220
canonical_skill_added AKS 1221
canonical_skill_added ACR 1222
dimension_skill_link FastAPI ↔ React Frontend Development 96
dimension_skill_link Databricks ↔ React Frontend Development 96
dimension_skill_link Unity Catalog ↔ Data Lineage and Metadata 28
dimension_skill_link Unity Catalog ↔ React Frontend Development 96
dimension_skill_link Agentic workflows ↔ React Frontend Development 96
dimension_skill_link Vector DB ↔ React Frontend Development 96
dimension_skill_link Hybrid Search ↔ React Frontend Development 96
dimension_skill_link Prompt engineering ↔ React Frontend Development 96
dimension_skill_link AWS Bedrock ↔ Cloud Platforms 20
dimension_skill_link DSPy ↔ React Frontend Development 96
dimension_skill_link Redshift ↔ Cloud Platforms 20
dimension_skill_link RDS ↔ Cloud Platforms 20
dimension_skill_link S3 ↔ Cloud Platforms 20
dimension_skill_link S3 ↔ React Frontend Development 96
dimension_skill_link S3 ↔ Systems Programming 166
dimension_skill_link Vector Search ↔ React Frontend Development 96
dimension_skill_link Azure DevOps ↔ CI/CD Pipeline Platforms 150
dimension_skill_link Scrum ↔ React Frontend Development 96
dimension_skill_link DevOps ↔ CI/CD Pipeline Platforms 150
dimension_skill_link DevOps ↔ Infrastructure as Code 132
dimension_skill_link DevOps ↔ Deployment and Release Patterns 140
dimension_skill_link IAM ↔ React Frontend Development 96
dimension_skill_link Monitoring ↔ Observability and Incident Triage 155
dimension_skill_link Load Balancing ↔ Deployment and Release Patterns 140
dimension_skill_link ECR ↔ Cloud Platforms 20
dimension_skill_link AKS ↔ Container Orchestration Platforms 134
dimension_skill_link ACR ↔ React Frontend Development 96
dimension_skill_link ACR ↔ Cloud Platforms 20
nano JD Parser — gpt-4.1-nano click to toggle
RoleAI Engineer
Experience3+ years
CTC{'max': 1.3, 'min': 1.2, 'raw': '1.2-1.3 LPM', 'period': 'monthly', 'currency': 'INR'}
DomainOther
Location Noida (onsite)
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": null,
  "ctc": {
    "currency": "INR",
    "max": 1.3,
    "min": 1.2,
    "period": "monthly",
    "raw": "1.2-1.3 LPM"
  },
  "domain": {
    "primary": {
      "aliases": [],
      "domain": "Other"
    },
    "secondary": null
  },
  "education": [
    {
      "level": "Bachelor\u0027s",
      "qualification": "BTECH/BE - Computer Science (or related)",
      "raw": "Bachelor\u2019s degree in computer science, Information Technology, or a related field (or equivalent work experience).",
      "requirement": "required"
    }
  ],
  "experience": {
    "max": null,
    "min": 3,
    "raw": "3+ years"
  },
  "job_locations": [
    {
      "aliases": [],
      "city": "Noida",
      "country": null,
      "state": null,
      "work_mode": "onsite"
    },
    {
      "aliases": [],
      "city": "Pune",
      "country": null,
      "state": null,
      "work_mode": "onsite"
    },
    {
      "aliases": [
        "Bengaluru"
      ],
      "city": "Bangalore",
      "country": null,
      "state": null,
      "work_mode": "onsite"
    }
  ],
  "role": "AI Engineer",
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 0,
      "heading": "What They Will Do",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Take ownership of architecture design",
        "last_5_words": "design and best practices."
      },
      "text": "Take ownership of architecture design and development of scalable and distributed software systems.\nTranslate business to technical requirements\nOwn technical execution, ensuring code quality, adherence to deadlines, and efficient resource allocation\nData driven decision making skills with focus on achieving product goals\nDesign, develop and deploy LLM based pipelines involving patterns like RAG, Agentic workflows,\nResponsible for the complete software development lifecycle, including requirements analysis, design, coding, testing, and deployment.\nUtilize AWS services/ Azure services like IAM, Monitoring, Load Balancing, Autoscaling, Database, Networking, storage, ECR, AKS, ACR etc.\nUtilize Databricks capabilities, esp. Unity Catalog and be able to architect the governance layer from data all-the-way to the AI model output\nDesign, develop and deploy prompt and response guardrails to enable responsible AI requirements\nImplement DevOps practices using tools like Docker, Kubernetes to ensure continuous integration and delivery. Develop DevOps scripts for automation and monitoring.\nCollaborate with cross-functional teams, conduct code reviews, and provide guidance on software design and best practices.",
      "word_count": 218
    },
    {
      "bullet_count": 0,
      "heading": "What They Will Bring",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Bachelor\u2019s degree in computer science",
        "last_5_words": "development and delivery"
      },
      "text": "Bachelor\u2019s degree in computer science, Information Technology, or a related field (or equivalent work experience).\nStrong coding skills with proficiency in Python\nExperience with API frameworks both stateless and stateful such as Fast API, Django\nProficient in cloud platforms, specifically AWS, Databricks and Azure\nProficient in Infra-as-Code, esp. focused on developing Terraform scripts and Cloudformation\nKnowledge and hands-on experience with front-end development (React JS, Next JS, Tailwind CSS) preferred\nStrong experience in LLM patterns like RAG, Vector DB, Hybrid Search, Agent development, Agentic workflows, prompt engineering, etc.\nStrong experience with LLM APIs (Open AI, Anthropic, AWS Bedrock), SDKs (Langchain, DSPy)\nHands-on experience with DevOps tools including Docker, Kubernetes, and AWS services (Redshift, RDS, S3).\nHands-on experience with Databricks solutions including Unity Catalog.\nExperience in production deployments involving thousands of users, esp with capabilities like Redis, Vector Search, etc.\nStrong understanding of scalable application design principles and experience with security best practices and compliance with privacy regulations.\nGood knowledge of software engineering practices like version control (GIT), DevOps (Azure DevOps preferred) and Agile or Scrum.\nStrong communication skills, with the ability to effectively convey complex technical concepts to a diverse audience.\nExperience of SDLC and best practices while development\nExperience with Agile methodology for continuous product development and delivery",
      "word_count": 263
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Python"
    },
    {
      "is_primary": true,
      "skill_name": "FastAPI"
    },
    {
      "is_primary": true,
      "skill_name": "Django"
    },
    {
      "is_primary": true,
      "skill_name": "AWS"
    },
    {
      "is_primary": true,
      "skill_name": "Azure"
    },
    {
      "is_primary": true,
      "skill_name": "Databricks"
    },
    {
      "is_primary": true,
      "skill_name": "Unity Catalog"
    },
    {
      "is_primary": true,
      "skill_name": "Terraform"
    },
    {
      "is_primary": true,
      "skill_name": "CloudFormation"
    },
    {
      "is_primary": false,
      "skill_name": "React"
    },
    {
      "is_primary": false,
      "skill_name": "Next.js"
    },
    {
      "is_primary": false,
      "skill_name": "Tailwind CSS"
    },
    {
      "is_primary": true,
      "skill_name": "RAG"
    },
    {
      "is_primary": true,
      "skill_name": "Agentic workflows"
    },
    {
      "is_primary": true,
      "skill_name": "Vector DB"
    },
    {
      "is_primary": true,
      "skill_name": "Hybrid Search"
    },
    {
      "is_primary": true,
      "skill_name": "Prompt engineering"
    },
    {
      "is_primary": true,
      "skill_name": "OpenAI"
    },
    {
      "is_primary": true,
      "skill_name": "Anthropic"
    },
    {
      "is_primary": true,
      "skill_name": "AWS Bedrock"
    },
    {
      "is_primary": true,
      "skill_name": "LangChain"
    },
    {
      "is_primary": true,
      "skill_name": "DSPy"
    },
    {
      "is_primary": true,
      "skill_name": "Docker"
    },
    {
      "is_primary": true,
      "skill_name": "Kubernetes"
    },
    {
      "is_primary": false,
      "skill_name": "Redshift"
    },
    {
      "is_primary": false,
      "skill_name": "RDS"
    },
    {
      "is_primary": false,
      "skill_name": "S3"
    },
    {
      "is_primary": false,
      "skill_name": "Redis"
    },
    {
      "is_primary": false,
      "skill_name": "Vector Search"
    },
    {
      "is_primary": true,
      "skill_name": "Git"
    },
    {
      "is_primary": false,
      "skill_name": "Azure DevOps"
    },
    {
      "is_primary": true,
      "skill_name": "Agile"
    },
    {
      "is_primary": false,
      "skill_name": "Scrum"
    },
    {
      "is_primary": true,
      "skill_name": "DevOps"
    },
    {
      "is_primary": true,
      "skill_name": "CI/CD"
    },
    {
      "is_primary": false,
      "skill_name": "IAM"
    },
    {
      "is_primary": false,
      "skill_name": "Monitoring"
    },
    {
      "is_primary": false,
      "skill_name": "Load Balancing"
    },
    {
      "is_primary": false,
      "skill_name": "Autoscaling"
    },
    {
      "is_primary": false,
      "skill_name": "ECR"
    },
    {
      "is_primary": false,
      "skill_name": "AKS"
    },
    {
      "is_primary": false,
      "skill_name": "ACR"
    }
  ],
  "jd_role": {
    "display_name": "AI Engineer",
    "rationale": null,
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": null,
    "ctc": {
      "currency": "INR",
      "max": 1.3,
      "min": 1.2,
      "period": "monthly",
      "raw": "1.2-1.3 LPM"
    },
    "domain": {
      "primary": {
        "aliases": [],
        "domain": "Other"
      },
      "secondary": null
    },
    "education": [
      {
        "level": "Bachelor\u0027s",
        "qualification": "BTECH/BE - Computer Science (or related)",
        "raw": "Bachelor\u2019s degree in computer science, Information Technology, or a related field (or equivalent work experience).",
        "requirement": "required"
      }
    ],
    "experience": {
      "max": null,
      "min": 3,
      "raw": "3+ years"
    },
    "job_locations": [
      {
        "aliases": [],
        "city": "Noida",
        "country": null,
        "state": null,
        "work_mode": "onsite"
      },
      {
        "aliases": [],
        "city": "Pune",
        "country": null,
        "state": null,
        "work_mode": "onsite"
      },
      {
        "aliases": [
          "Bengaluru"
        ],
        "city": "Bangalore",
        "country": null,
        "state": null,
        "work_mode": "onsite"
      }
    ],
    "role": "AI Engineer",
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 0,
        "heading": "What They Will Do",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Take ownership of architecture design",
          "last_5_words": "design and best practices."
        },
        "text": "Take ownership of architecture design and development of scalable and distributed software systems.\nTranslate business to technical requirements\nOwn technical execution, ensuring code quality, adherence to deadlines, and efficient resource allocation\nData driven decision making skills with focus on achieving product goals\nDesign, develop and deploy LLM based pipelines involving patterns like RAG, Agentic workflows,\nResponsible for the complete software development lifecycle, including requirements analysis, design, coding, testing, and deployment.\nUtilize AWS services/ Azure services like IAM, Monitoring, Load Balancing, Autoscaling, Database, Networking, storage, ECR, AKS, ACR etc.\nUtilize Databricks capabilities, esp. Unity Catalog and be able to architect the governance layer from data all-the-way to the AI model output\nDesign, develop and deploy prompt and response guardrails to enable responsible AI requirements\nImplement DevOps practices using tools like Docker, Kubernetes to ensure continuous integration and delivery. Develop DevOps scripts for automation and monitoring.\nCollaborate with cross-functional teams, conduct code reviews, and provide guidance on software design and best practices.",
        "word_count": 218
      },
      {
        "bullet_count": 0,
        "heading": "What They Will Bring",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Bachelor\u2019s degree in computer science",
          "last_5_words": "development and delivery"
        },
        "text": "Bachelor\u2019s degree in computer science, Information Technology, or a related field (or equivalent work experience).\nStrong coding skills with proficiency in Python\nExperience with API frameworks both stateless and stateful such as Fast API, Django\nProficient in cloud platforms, specifically AWS, Databricks and Azure\nProficient in Infra-as-Code, esp. focused on developing Terraform scripts and Cloudformation\nKnowledge and hands-on experience with front-end development (React JS, Next JS, Tailwind CSS) preferred\nStrong experience in LLM patterns like RAG, Vector DB, Hybrid Search, Agent development, Agentic workflows, prompt engineering, etc.\nStrong experience with LLM APIs (Open AI, Anthropic, AWS Bedrock), SDKs (Langchain, DSPy)\nHands-on experience with DevOps tools including Docker, Kubernetes, and AWS services (Redshift, RDS, S3).\nHands-on experience with Databricks solutions including Unity Catalog.\nExperience in production deployments involving thousands of users, esp with capabilities like Redis, Vector Search, etc.\nStrong understanding of scalable application design principles and experience with security best practices and compliance with privacy regulations.\nGood knowledge of software engineering practices like version control (GIT), DevOps (Azure DevOps preferred) and Agile or Scrum.\nStrong communication skills, with the ability to effectively convey complex technical concepts to a diverse audience.\nExperience of SDLC and best practices while development\nExperience with Agile methodology for continuous product development and delivery",
        "word_count": 263
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "c2572c5b-9053-41b1-b0ec-8b73981437bd",
  "stage3_signals": {
    "alias_match_roles": [
      {
        "display_name": "AI Engineer",
        "matched_count": null,
        "role_id": 13,
        "score": 1.0,
        "slug": "ai-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "AI Compliance Officer",
        "matched_count": null,
        "role_id": 12,
        "score": 0.4931,
        "slug": "ai-compliance-officer",
        "total_count": null
      },
      {
        "display_name": "AR/VR Engineer",
        "matched_count": null,
        "role_id": 8,
        "score": 0.4711,
        "slug": "ar-vr-engineer",
        "total_count": null
      },
      {
        "display_name": "Android Engineer",
        "matched_count": null,
        "role_id": 4,
        "score": 0.4616,
        "slug": "android-engineer",
        "total_count": null
      },
      {
        "display_name": "Cloud Architect",
        "matched_count": null,
        "role_id": 9,
        "score": 0.4567,
        "slug": "cloud-architect",
        "total_count": null
      },
      {
        "display_name": "Backend Engineer",
        "matched_count": null,
        "role_id": 1,
        "score": 0.4563,
        "slug": "backend-engineer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "DevOps Engineer",
        "matched_count": 8,
        "role_id": 10,
        "score": 0.1905,
        "slug": "devops-engineer",
        "total_count": 42
      },
      {
        "display_name": "Backend Engineer",
        "matched_count": 6,
        "role_id": 1,
        "score": 0.1429,
        "slug": "backend-engineer",
        "total_count": 42
      },
      {
        "display_name": "Cloud Architect",
        "matched_count": 6,
        "role_id": 9,
        "score": 0.1429,
        "slug": "cloud-architect",
        "total_count": 42
      },
      {
        "display_name": "ML Engineer",
        "matched_count": 6,
        "role_id": 3,
        "score": 0.1429,
        "slug": "ml-engineer",
        "total_count": 42
      },
      {
        "display_name": "Frontend Engineer",
        "matched_count": 3,
        "role_id": 7,
        "score": 0.0714,
        "slug": "frontend-engineer",
        "total_count": 42
      }
    ],
    "stage35_ran": false
  },
  "stage4_decision": {
    "alias_collision_detected": true,
    "case": "D",
    "chosen_role": {
      "display_name": "AI Engineer",
      "matched_count": null,
      "role_id": 13,
      "score": 1.0,
      "slug": "ai-engineer",
      "total_count": null
    },
    "confidence": 0.95,
    "llm2_fired": true,
    "llm2_reasoning": "The JD\u2019s emphasis on end-to-end architecture, scalable software development, LLM pipelines, cloud/DevOps, and prompt engineering aligns directly with the day-to-day responsibilities of an AI Engineer rather than an AI Compliance Officer.",
    "queued": false,
    "reasoning": "LLM2 picked ai-engineer (confidence 0.95)"
  },
  "stage5_updates": {
    "centroid_n_after": 2,
    "centroid_updated": true,
    "collision_log_id": 10,
    "new_kra_attached": {
      "best_kra_similarity": 0.0,
      "queue_id": 6,
      "r_and_r_preview": "Take ownership of architecture design and development of scalable and distributed software systems.\nTranslate business to technical requirements\nOwn technical execution, ensuring code quality, adheren",
      "role_display_name": "AI Engineer",
      "role_slug": "ai-engineer",
      "status": "pending"
    },
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 79,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "FastAPI",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 80,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Databricks",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 81,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Unity Catalog",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 82,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Agentic workflows",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 83,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Vector DB",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 84,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Hybrid Search",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 85,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Prompt engineering",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 86,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "AWS Bedrock",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 87,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "DSPy",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 88,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Redshift",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 89,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "RDS",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 90,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "S3",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 91,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Vector Search",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 92,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Azure DevOps",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 93,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Scrum",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 94,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "DevOps",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 95,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "IAM",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 96,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Monitoring",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 97,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "Load Balancing",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 98,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "ECR",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 99,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "AKS",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 100,
        "role_display_name": "AI Engineer",
        "role_slug": "ai-engineer",
        "skill_name": "ACR",
        "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": 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": 416,
        "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": 82,
      "existing_alias_text": "Django",
      "input_term": "Django",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Django",
        "id": 9,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "django",
        "sub_category_id": 35,
        "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": 406,
      "existing_alias_text": "AWS",
      "input_term": "AWS",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "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": 407,
      "existing_alias_text": "Azure",
      "input_term": "Azure",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Azure",
        "id": 188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "sub_category_id": 46,
        "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": 547,
      "existing_alias_text": "Terraform",
      "input_term": "Terraform",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Terraform",
        "id": 286,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "terraform",
        "sub_category_id": 191,
        "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": 1382,
      "existing_alias_text": "CloudFormation",
      "input_term": "CloudFormation",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "CloudFormation",
        "id": 837,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "cloudformation",
        "sub_category_id": 181,
        "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": 1047,
      "existing_alias_text": "React",
      "input_term": "React",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 341,
        "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": 1210,
      "existing_alias_text": "Next.js",
      "input_term": "Next.js",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Next.js",
        "id": 705,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "next-js",
        "sub_category_id": 35,
        "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": 1111,
      "existing_alias_text": "Tailwind CSS",
      "input_term": "Tailwind CSS",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Tailwind CSS",
        "id": 627,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "tailwind-css",
        "sub_category_id": 481,
        "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": 1830,
      "existing_alias_text": "RAG",
      "input_term": "RAG",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "RAG",
        "id": 1194,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rag",
        "sub_category_id": 904,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1822,
      "existing_alias_text": "OpenAI",
      "input_term": "OpenAI",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "OpenAI",
        "id": 1186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "openai",
        "sub_category_id": 896,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1824,
      "existing_alias_text": "Anthropic",
      "input_term": "Anthropic",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Anthropic",
        "id": 1188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "anthropic",
        "sub_category_id": 898,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 501,
      "existing_alias_text": "LangChain",
      "input_term": "LangChain",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "LangChain",
        "id": 240,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "langchain",
        "sub_category_id": 146,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 198,
      "existing_alias_text": "Docker",
      "input_term": "Docker",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 654,
        "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": 1267,
      "existing_alias_text": "Kubernetes",
      "input_term": "Kubernetes",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "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": 168,
      "existing_alias_text": "Redis",
      "input_term": "Redis",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Redis",
        "id": 31,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "redis",
        "sub_category_id": 28,
        "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": 1613,
      "existing_alias_text": "Git",
      "input_term": "Git",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Git",
        "id": 1002,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "git",
        "sub_category_id": 730,
        "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": 868,
      "existing_alias_text": "Agile",
      "input_term": "Agile",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "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": 1826,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "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": 1406,
      "existing_alias_text": "autoscaling",
      "input_term": "Autoscaling",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "autoscaling",
        "id": 858,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "autoscaling",
        "sub_category_id": 604,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Backend Engineer",
      "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": "Cybersecurity 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": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "Frontend Engineer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "AI Engineer",
    "id": null,
    "rationale": "The primary skills indicate a strong emphasis on AI technologies and cloud-based solutions.",
    "role_archetype": "Engineering role focused on developing AI solutions and infrastructure.",
    "slug": "ai-engineer",
    "source": "llm"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Core server-side languages used to implement backend business logic, integrations, and service internals. This is the primary coding surface for the role across application layers.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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"
        }
      ]
    },
    {
      "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": "Cybersecurity 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"
        }
      ]
    },
    {
      "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": "Web Application Frameworks",
        "id": 2,
        "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
        "slug": "web-application-frameworks",
        "source": "db"
      },
      "input_skill": "Django",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "Terraform",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code for ML",
        "id": 57,
        "rationale": "Tools for provisioning and managing ML infrastructure resources through code.",
        "slug": "infrastructure-as-code-for-ml",
        "source": "db"
      },
      "input_skill": "Terraform",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "CloudFormation",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "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": "Meta-Frameworks \u0026 SSR",
        "id": 130,
        "rationale": "Frameworks that build on UI libraries to provide routing, server-side rendering, and static site generation.",
        "slug": "meta-frameworks-ssr",
        "source": "db"
      },
      "input_skill": "Next.js",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CSS Architecture and Styling",
        "id": 117,
        "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
        "slug": "css-architecture-and-styling",
        "source": "db"
      },
      "input_skill": "Tailwind CSS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-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": "RAG",
      "llm_role": null,
      "roles_from_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": "OpenAI",
      "llm_role": null,
      "roles_from_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": "Anthropic",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "LLM Operations and Orchestration",
        "id": 49,
        "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
        "slug": "llm-operations-and-orchestration",
        "source": "db"
      },
      "input_skill": "LangChain",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Containerization and Image Builds",
        "id": 152,
        "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
        "slug": "containerization-and-image-builds",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Runtime Configuration",
        "id": 13,
        "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
        "slug": "deployment-and-runtime-configuration",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "Kubernetes",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Caching and State Management",
        "id": 7,
        "rationale": "Techniques and systems for reducing latency and managing ephemeral backend state. Covers cache-aside patterns, distributed caches, session stores, and invalidation strategies.",
        "slug": "caching-and-state-management",
        "source": "db"
      },
      "input_skill": "Redis",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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"
        }
      ]
    },
    {
      "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": "Git",
      "llm_role": null,
      "roles_from_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": "Agile",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "Autoscaling",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-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": "FastAPI",
      "llm_role": null,
      "roles_from_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": "Databricks",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Data Lineage and Metadata",
        "id": 28,
        "rationale": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
        "slug": "data-lineage-and-metadata",
        "source": "db"
      },
      "input_skill": "Unity Catalog",
      "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": "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": "Unity Catalog",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Data Lineage and Metadata",
        "id": 28,
        "rationale": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
        "slug": "data-lineage-and-metadata",
        "source": "db"
      },
      "input_skill": "Unity Catalog",
      "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": "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": "Agentic workflows",
      "llm_role": null,
      "roles_from_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": "Vector DB",
      "llm_role": null,
      "roles_from_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": "Hybrid Search",
      "llm_role": null,
      "roles_from_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": "Prompt engineering",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS Bedrock",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS Bedrock",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-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": "DSPy",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "Redshift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "RDS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "S3",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-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": "S3",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Systems Programming",
        "id": 166,
        "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
        "slug": "d_init_02",
        "source": "db"
      },
      "input_skill": "S3",
      "llm_role": null,
      "roles_from_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": "Vector Search",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "Azure DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "Azure DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-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": "Scrum",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "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": "IAM",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Observability and Incident Triage",
        "id": 155,
        "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
        "slug": "observability-and-incident-triage",
        "source": "db"
      },
      "input_skill": "Monitoring",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Observability and Incident Triage",
        "id": 155,
        "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
        "slug": "observability-and-incident-triage",
        "source": "db"
      },
      "input_skill": "Monitoring",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "Load Balancing",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "Load Balancing",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "ECR",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "AKS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "AKS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-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": "ACR",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "ACR",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Proficiency in major cloud service provider platforms and their core services.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "ACR",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "Python",
    "FastAPI",
    "Django",
    "AWS",
    "Azure",
    "Databricks",
    "Unity Catalog",
    "Terraform",
    "CloudFormation",
    "React",
    "Next.js",
    "Tailwind CSS",
    "RAG",
    "Agentic workflows",
    "Vector DB",
    "Hybrid Search",
    "Prompt engineering",
    "OpenAI",
    "Anthropic",
    "AWS Bedrock",
    "LangChain",
    "DSPy",
    "Docker",
    "Kubernetes",
    "Redshift",
    "RDS",
    "S3",
    "Redis",
    "Vector Search",
    "Git",
    "Azure DevOps",
    "Agile",
    "Scrum",
    "DevOps",
    "CI/CD",
    "IAM",
    "Monitoring",
    "Load Balancing",
    "Autoscaling",
    "ECR",
    "AKS",
    "ACR"
  ],
  "input_llm_skills": [
    "Python",
    "FastAPI",
    "Django",
    "AWS",
    "Azure",
    "Databricks",
    "Unity Catalog",
    "Terraform",
    "CloudFormation",
    "React",
    "Next.js",
    "Tailwind CSS",
    "RAG",
    "Agentic workflows",
    "Vector DB",
    "Hybrid Search",
    "Prompt engineering",
    "OpenAI",
    "Anthropic",
    "AWS Bedrock",
    "LangChain",
    "DSPy",
    "Docker",
    "Kubernetes",
    "Redshift",
    "RDS",
    "S3",
    "Redis",
    "Vector Search",
    "Git",
    "Azure DevOps",
    "Agile",
    "Scrum",
    "DevOps",
    "CI/CD",
    "IAM",
    "Monitoring",
    "Load Balancing",
    "Autoscaling",
    "ECR",
    "AKS",
    "ACR"
  ],
  "new_aliases_persisted": 0,
  "run_id": "c2572c5b-9053-41b1-b0ec-8b73981437bd",
  "skills_detail": [
    {
      "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": "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": "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"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 416,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Core server-side languages used to implement backend business logic, integrations, and service internals. This is the primary coding surface for the role across application layers.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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"
            }
          ]
        },
        {
          "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": "Cybersecurity 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"
            }
          ]
        },
        {
          "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"
            }
          ]
        }
      ],
      "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": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "FastAPI",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "FastAPI",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Framework",
          "skill_nature": "FRAMEWORK",
          "sub_category": "web_framework",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "FastAPI is a specific Python web framework; typical JDs won\u2019t confuse it with other catalog frameworks."
          },
          "context_keywords": {
            "context_keywords": [
              "Starlette",
              "Pydantic",
              "async",
              "uvicorn",
              "RESTful",
              "OpenAPI",
              "dependency injection",
              "middleware",
              "JSON",
              "WebSocket",
              "OAuth2",
              "CORS",
              "data validation",
              "API documentation",
              "type hints"
            ]
          },
          "maturity": {
            "confidence": 0.91,
            "maturity": "well_known",
            "reasoning": "FastAPI appears in many Python backend job postings and is a common choice in modern API stacks; GitHub usage and ecosystem activity remain strong, with no vendor sunset or replacement trend."
          },
          "skill_id": "fastapi",
          "vendor_license": {
            "confidence": 0.95,
            "license": "mit",
            "vendor": "Sebasti\u00e1n Ram\u00edrez",
            "year_introduced": 2018
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Frameworks used to build HTTP APIs and backend services in Python. FastAPI belongs here because it is a Python-first framework for defining routes, request/response models, validation, and API documentation.",
            "exemplar_skills": [
              "FastAPI",
              "Flask",
              "Django REST Framework",
              "Starlette",
              "Pydantic",
              "OpenAPI",
              "Python API development"
            ],
            "in_scope": "FastAPI, Flask, Django REST Framework, Starlette, route handlers, request parsing, response serialization, dependency injection, Pydantic models, OpenAPI generation, async endpoints",
            "name": "Python Web API Frameworks",
            "out_of_scope": "Frontend UI frameworks and browser rendering, mobile app UI frameworks, container orchestration, database administration, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "FastAPI applications often use dependency injection patterns, but the framework dimension is primarily about API construction rather than overall application structure.",
                "with_dim_id": "app-architecture-and-dependency-injection",
                "with_dim_name": null,
                "with_role": "Android Engineer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "FastAPI",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "fastapi"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "apis",
            "fetch-api",
            "axios",
            "oauth-2-0",
            "openai",
            "github-actions"
          ],
          "requires": [],
          "skill_id": "fastapi",
          "suppress_on_match": []
        },
        "skill_id": "fastapi",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "FastAPI",
          "reasoning": "FastAPI is a framework because developers build applications inside it and it provides the application structure and request handling rather than being a standalone library or tool.",
          "skill_id": "fastapi",
          "subtype": "web_framework",
          "type": "Framework"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Django",
          "alias_type": "CANONICAL",
          "id": 82,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 1",
          "alias_type": "VERSION",
          "id": 83,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 1.x",
          "alias_type": "VERSION",
          "id": 88,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 2",
          "alias_type": "VERSION",
          "id": 84,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 2.x",
          "alias_type": "VERSION",
          "id": 89,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 3",
          "alias_type": "VERSION",
          "id": 85,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 3.x",
          "alias_type": "VERSION",
          "id": 90,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 4",
          "alias_type": "VERSION",
          "id": 86,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 4.x",
          "alias_type": "VERSION",
          "id": 91,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 5",
          "alias_type": "VERSION",
          "id": 87,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Django 5.x",
          "alias_type": "VERSION",
          "id": 92,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Django",
        "id": 9,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "django",
        "sub_category_id": 35,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Application Frameworks",
            "id": 2,
            "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
            "slug": "web-application-frameworks",
            "source": "db"
          },
          "input_skill": "Django",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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"
            }
          ]
        }
      ],
      "input_skill": "Django",
      "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": "AWS",
          "alias_type": "CANONICAL",
          "id": 406,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AWS",
      "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": "Azure",
          "alias_type": "CANONICAL",
          "id": 407,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Azure",
        "id": 188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Azure",
      "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": [
        {
          "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": "Databricks",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Databricks",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "data_analytics_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cDatabricks\u201d is a specific vendor/platform name; unlikely to be confused with other distinct skills in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "Spark",
              "Delta Lake",
              "MLflow",
              "notebooks",
              "data pipelines",
              "collaborative workspace",
              "SQL Analytics",
              "data lakes",
              "Apache Spark",
              "data engineering",
              "machine learning",
              "data visualization",
              "job scheduling",
              "Databricks Runtime",
              "cloud integration",
              "real-time analytics"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Databricks appears frequently in data engineering and analytics job postings, especially alongside Spark, Delta Lake, and lakehouse stacks; strong vendor adoption and broad enterprise usage signal mainstream demand."
          },
          "skill_id": "databricks",
          "vendor_license": {
            "confidence": 0.95,
            "license": "other_open",
            "vendor": "Databricks, Inc.",
            "year_introduced": 2013
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Databricks is a unified lakehouse platform for data engineering, analytics, and machine learning workloads. It belongs here because the skill refers to operating and building on the Databricks environment rather than a single language or algorithm.",
            "exemplar_skills": [
              "Databricks",
              "Databricks SQL",
              "Delta Lake",
              "Unity Catalog",
              "Databricks Jobs",
              "Databricks notebooks",
              "Databricks clusters",
              "MLflow on Databricks"
            ],
            "in_scope": "Databricks workspace administration, Databricks notebooks, Databricks SQL, Delta Lake, Unity Catalog, Databricks Jobs, clusters and compute, lakehouse pipelines, MLflow on Databricks, Databricks Repos, Databricks Connect",
            "name": "Lakehouse Data Platform",
            "out_of_scope": "General cloud provider services, container orchestration, raw Spark programming without Databricks-specific platform usage, standalone BI tools, generic ML frameworks not tied to Databricks",
            "overlap_flags": [
              {
                "reason": "Databricks runs as a managed cloud service and often overlaps with cloud account, networking, and identity setup.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              },
              {
                "reason": "Databricks commonly hosts MLflow and model training workflows, which can overlap with general ML platform usage.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "Unity Catalog and related governance features can overlap with lineage, cataloging, and metadata management.",
                "with_dim_id": "data-lineage-and-metadata",
                "with_dim_name": null,
                "with_role": "Data Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Databricks",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "databricks"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "microsoft-azure",
            "aws",
            "ibm-cloud",
            "managed-databases",
            "amazon-s3",
            "kubernetes",
            "grafana",
            "datadog"
          ],
          "requires": [],
          "skill_id": "databricks",
          "suppress_on_match": []
        },
        "skill_id": "databricks",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "Databricks",
          "reasoning": "By the Platform vs Tool rule, Databricks is a hosted multi-tenant environment with APIs and managed services rather than software you run yourself.",
          "skill_id": "databricks",
          "subtype": "data_analytics_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Data Lineage and Metadata",
            "id": 28,
            "rationale": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
            "slug": "data-lineage-and-metadata",
            "source": "db"
          },
          "input_skill": "Unity Catalog",
          "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": "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": "Unity Catalog",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Data Lineage and Metadata",
            "id": 28,
            "rationale": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
            "slug": "data-lineage-and-metadata",
            "source": "db"
          },
          "input_skill": "Unity Catalog",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Unity Catalog",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "data_governance_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cUnity Catalog\u201d is a specific data governance/lineage platform name; unlikely to be confused with other catalog-like skills in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "data governance",
              "metadata management",
              "data lineage",
              "access control",
              "data catalog",
              "audit logs",
              "data quality",
              "schema enforcement",
              "collaboration",
              "data privacy",
              "role-based access",
              "data classification",
              "data sharing",
              "data discovery",
              "compliance"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Appears increasingly in Databricks and data-governance job postings, but JD volume is still far below core platforms like AWS or PostgreSQL; adoption is growing with Unity Catalog positioned as Databricks\u2019 unified governance layer."
          },
          "skill_id": "unity-catalog",
          "vendor_license": {
            "confidence": 0.85,
            "license": "unknown",
            "vendor": "Databricks",
            "year_introduced": 2021
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Cataloging, documenting, and tracing how data assets are organized, governed, and discovered across systems. Unity Catalog belongs here because it is a metadata and governance layer for tables, views, files, permissions, and lineage in the Databricks ecosystem.",
            "exemplar_skills": [
              "Unity Catalog",
              "data lineage",
              "metadata management",
              "table governance",
              "schema organization",
              "data discovery",
              "permissioned data access",
              "Databricks catalog administration"
            ],
            "in_scope": "Unity Catalog, table and schema metadata, catalog organization, data asset discovery, lineage tracking, permissions on data objects, tags and comments, external locations, managed and external tables, Databricks metadata governance",
            "name": "Data Lineage and Metadata",
            "out_of_scope": "Model training orchestration, notebook development, ETL job scheduling, Kubernetes cluster administration, cloud account setup, these belong to other platform or ML operations dimensions",
            "overlap_flags": [
              {
                "reason": "Unity Catalog can support governance controls, but policy review and approval workflows are owned by the compliance dimension.",
                "with_dim_id": "ai-use-case-compliance-review",
                "with_dim_name": null,
                "with_role": "AI Compliance Officer"
              },
              {
                "reason": "It includes access control and sensitive-data governance, but broader data protection and leakage prevention belong to the security dimension.",
                "with_dim_id": "data-security-and-dlp",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "data-lineage-and-metadata"
          },
          {
            "description": "Governance features specific to Databricks for controlling access, organizing data assets, and managing cross-workspace metadata. This is a reasonable fit when Unity Catalog is used as the primary governance plane rather than just generic metadata tooling.",
            "exemplar_skills": [
              "Unity Catalog",
              "Databricks governance",
              "catalog and schema grants",
              "external locations",
              "storage credentials",
              "governed data sharing",
              "workspace access control",
              "Databricks data access administration"
            ],
            "in_scope": "Unity Catalog, Databricks catalogs and schemas, workspace-to-catalog access patterns, grants and privileges, external locations, storage credentials, governed data sharing, Databricks governance administration",
            "name": "Databricks Data Governance",
            "out_of_scope": "General cloud IAM, non-Databricks data catalogs, ML model registry operations, pipeline scheduling, notebook authoring, these are owned by cloud security, metadata, or ML platform dimensions",
            "overlap_flags": [
              {
                "reason": "Governed access to sensitive data overlaps with security controls, but DLP and broader protection policies are covered there.",
                "with_dim_id": "data-security-and-dlp",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
            "exemplar_skills": [
              "Data Lineage and Metadata"
            ],
            "in_scope": "Skills, tools, and practices that belong under Data Lineage and Metadata for the target role, including items implied by the dimension rationale.",
            "name": "Data Lineage and Metadata",
            "out_of_scope": "Adjacent clusters explicitly not owned by Data Lineage and Metadata, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "data-lineage-and-metadata"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Unity Catalog",
          "placement_confidence": 0.92,
          "primary_dimension": "data-lineage-and-metadata",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_01"
          ],
          "skill_id": "unity-catalog"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [],
          "requires": [],
          "skill_id": "unity-catalog",
          "suppress_on_match": []
        },
        "skill_id": "unity-catalog",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Unity Catalog",
          "reasoning": "By the Platform vs Tool rule, Unity Catalog is a hosted, multi-tenant managed governance layer with APIs rather than software you run yourself, so it fits Platform.",
          "skill_id": "unity-catalog",
          "subtype": "data_governance_platform",
          "type": "Platform"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Terraform",
          "alias_type": "CANONICAL",
          "id": 547,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Terraform",
        "id": 286,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "terraform",
        "sub_category_id": 191,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "Terraform",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code for ML",
            "id": 57,
            "rationale": "Tools for provisioning and managing ML infrastructure resources through code.",
            "slug": "infrastructure-as-code-for-ml",
            "source": "db"
          },
          "input_skill": "Terraform",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Terraform",
      "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": "CloudFormation",
          "alias_type": "CANONICAL",
          "id": 1382,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "CloudFormation",
        "id": 837,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "cloudformation",
        "sub_category_id": 181,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "CloudFormation",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CloudFormation",
      "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": "React",
          "alias_type": "CANONICAL",
          "id": 1047,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.13",
          "alias_type": "VERSION",
          "id": 1052,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.14",
          "alias_type": "VERSION",
          "id": 1053,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15",
          "alias_type": "VERSION",
          "id": 1048,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15.x",
          "alias_type": "VERSION",
          "id": 1054,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16",
          "alias_type": "VERSION",
          "id": 1049,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16.x",
          "alias_type": "VERSION",
          "id": 1055,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17",
          "alias_type": "VERSION",
          "id": 1050,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17.x",
          "alias_type": "VERSION",
          "id": 1056,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18",
          "alias_type": "VERSION",
          "id": 1051,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18.x",
          "alias_type": "VERSION",
          "id": 1057,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 341,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React",
      "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": "Next.js",
          "alias_type": "CANONICAL",
          "id": 1210,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 10",
          "alias_type": "VERSION",
          "id": 1219,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 11",
          "alias_type": "VERSION",
          "id": 1220,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 12",
          "alias_type": "VERSION",
          "id": 1221,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 13",
          "alias_type": "VERSION",
          "id": 1222,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 14",
          "alias_type": "VERSION",
          "id": 1223,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 15",
          "alias_type": "VERSION",
          "id": 1224,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 2",
          "alias_type": "VERSION",
          "id": 1211,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 3",
          "alias_type": "VERSION",
          "id": 1212,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 4",
          "alias_type": "VERSION",
          "id": 1213,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 5",
          "alias_type": "VERSION",
          "id": 1214,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 6",
          "alias_type": "VERSION",
          "id": 1215,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 7",
          "alias_type": "VERSION",
          "id": 1216,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 8",
          "alias_type": "VERSION",
          "id": 1217,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next 9",
          "alias_type": "VERSION",
          "id": 1218,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 1",
          "alias_type": "VERSION",
          "id": 1225,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 10",
          "alias_type": "VERSION",
          "id": 1234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 11",
          "alias_type": "VERSION",
          "id": 1235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 12",
          "alias_type": "VERSION",
          "id": 1236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 13",
          "alias_type": "VERSION",
          "id": 1237,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 14",
          "alias_type": "VERSION",
          "id": 1238,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 15",
          "alias_type": "VERSION",
          "id": 1239,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 2",
          "alias_type": "VERSION",
          "id": 1226,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 3",
          "alias_type": "VERSION",
          "id": 1227,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 4",
          "alias_type": "VERSION",
          "id": 1228,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 5",
          "alias_type": "VERSION",
          "id": 1229,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 6",
          "alias_type": "VERSION",
          "id": 1230,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 7",
          "alias_type": "VERSION",
          "id": 1231,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 8",
          "alias_type": "VERSION",
          "id": 1232,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Next.js 9",
          "alias_type": "VERSION",
          "id": 1233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Next.js",
        "id": 705,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "next-js",
        "sub_category_id": 35,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Meta-Frameworks \u0026 SSR",
            "id": 130,
            "rationale": "Frameworks that build on UI libraries to provide routing, server-side rendering, and static site generation.",
            "slug": "meta-frameworks-ssr",
            "source": "db"
          },
          "input_skill": "Next.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Next.js",
      "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": "Tailwind CSS",
          "alias_type": "CANONICAL",
          "id": 1111,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Tailwind CSS",
        "id": 627,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "tailwind-css",
        "sub_category_id": 481,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CSS Architecture and Styling",
            "id": 117,
            "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
            "slug": "css-architecture-and-styling",
            "source": "db"
          },
          "input_skill": "Tailwind CSS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Tailwind CSS",
      "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": "RAG",
          "alias_type": "CANONICAL",
          "id": 1830,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "RAG",
        "id": 1194,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rag",
        "sub_category_id": 904,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "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": "RAG",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "RAG",
      "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": [
        {
          "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": "Agentic workflows",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agentic workflows",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Architecture",
          "skill_nature": "PATTERN",
          "sub_category": "agentic_workflow_architecture",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAgentic workflows\u201d is a specific architecture concept; typical JDs won\u2019t confuse it with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "workflow automation",
              "process orchestration",
              "event-driven",
              "microservices",
              "business rules",
              "state management",
              "service integration",
              "user-centric design",
              "API gateways",
              "data flow",
              "real-time processing",
              "declarative programming",
              "task scheduling",
              "system interoperability",
              "adaptive systems"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Job postings increasingly mention agentic workflows alongside LLM orchestration and tool-use, and GitHub activity around agent frameworks has surged, but it is not yet a universal hiring staple."
          },
          "skill_id": "agentic-workflows",
          "vendor_license": {
            "confidence": 0.6,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Designing and coordinating multi-step AI agent processes that plan, act, observe results, and adapt toward a goal. This covers workflow patterns where an LLM-driven agent uses tools, memory, and control logic to complete tasks autonomously or semi-autonomously.",
            "exemplar_skills": [
              "Agentic workflows",
              "Agent orchestration",
              "Planner-executor patterns",
              "Tool calling",
              "Multi-agent systems",
              "Human-in-the-loop review",
              "LangGraph",
              "AutoGen",
              "CrewAI"
            ],
            "in_scope": "Agentic workflows, multi-step agent plans, tool-using agents, autonomous task execution, planner-executor loops, reflection and retry logic, memory-augmented agents, multi-agent coordination, human-in-the-loop checkpoints, LangGraph agent flows, AutoGen workflows, CrewAI orchestration",
            "name": "Agentic Workflow Orchestration",
            "out_of_scope": "Model training and fine-tuning, prompt writing for single-turn chat, generic API integration without agent control flow, UI chat surfaces, batch ETL pipelines, these belong to ML frameworks, prompt engineering, application integration, or data engineering dimensions",
            "overlap_flags": [
              {
                "reason": "Agent workflows often rely on LLM/agent libraries, but this dimension is about orchestration patterns rather than core model APIs.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "Some agent systems are deployed through ML pipelines, but release automation is not the primary concern here.",
                "with_dim_id": "ci-cd-for-machine-learning",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Agentic workflows",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "agentic-workflows"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "intelligent-automation",
            "chatbots",
            "virtual-assistants",
            "crewai",
            "apis",
            "ci-cd",
            "rollback-automation",
            "idempotent-configuration"
          ],
          "requires": [],
          "skill_id": "agentic-workflows",
          "suppress_on_match": []
        },
        "skill_id": "agentic-workflows",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Concept: ruled out \u2014 it is broader than a single theory or principle and is primarily a build-shape pattern.",
            "Methodology: ruled out \u2014 it does not primarily describe a way of working/process like Agile or Scrum."
          ],
          "confidence": 0.88,
          "name": "Agentic workflows",
          "reasoning": "By the Architecture vs Concept rule, agentic workflows describe a system-shape/pattern for how autonomous agents are organized and interact, rather than a single knowledge unit or process.",
          "skill_id": "agentic-workflows",
          "subtype": "agentic_workflow_architecture",
          "type": "Architecture"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "Vector DB",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Vector DB",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Datastore",
          "skill_nature": "TOOL",
          "sub_category": "vector_database",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cVector DB\u201d in JDs typically refers specifically to vector databases for embeddings/search, not other datastore types."
          },
          "context_keywords": {
            "context_keywords": [
              "embedding",
              "similarity search",
              "nearest neighbors",
              "Pinecone",
              "Weaviate",
              "FAISS",
              "Annoy",
              "vector search",
              "semantic search",
              "real-time analytics",
              "data indexing",
              "machine learning",
              "natural language processing",
              "high-dimensional data",
              "scalability"
            ]
          },
          "maturity": {
            "confidence": 0.89,
            "maturity": "emerging",
            "reasoning": "Vector DBs are increasingly listed in AI/ML job descriptions and vendor ecosystems, but they\u2019re not yet a universal datastore staple like PostgreSQL or AWS."
          },
          "skill_id": "vector-db",
          "vendor_license": {
            "confidence": 0.85,
            "license": "proprietary",
            "vendor": "Pinecone",
            "year_introduced": 2020
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Datastores optimized for storing embeddings and performing nearest-neighbor similarity search over high-dimensional vectors. Vector DB belongs here because it refers to the database layer used for retrieval, indexing, and semantic search in AI systems.",
            "exemplar_skills": [
              "Vector DB",
              "vector databases",
              "similarity search",
              "semantic search",
              "ANN indexing",
              "HNSW",
              "Milvus",
              "Pinecone",
              "Weaviate",
              "Qdrant"
            ],
            "in_scope": "Vector DB, vector databases, embedding storage, ANN indexes, similarity search, semantic search, kNN retrieval, hybrid search, metadata filtering, HNSW, IVF, FAISS-backed services, Milvus, Pinecone, Weaviate, Qdrant",
            "name": "Vector Databases and Similarity Search",
            "out_of_scope": "Traditional relational databases and SQL modeling, document stores without vector indexing, embedding model training and generation, search relevance tuning in application code",
            "overlap_flags": [
              {
                "reason": "Embeddings are often produced by ML frameworks, but the vector database skill is about storage and retrieval rather than model definition or training.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "Vector stores often keep metadata for filtering and governance, but lineage and cataloging are separate concerns from vector indexing.",
                "with_dim_id": "data-lineage-and-metadata",
                "with_dim_name": null,
                "with_role": "Data Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Vector DB",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "vector-db"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "sqlite",
            "managed-databases",
            "data-structures",
            "model-versioning",
            "datadog",
            "chromadb",
            "watermelondb"
          ],
          "requires": [],
          "skill_id": "vector-db",
          "suppress_on_match": []
        },
        "skill_id": "vector-db",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "Vector DB",
          "reasoning": "By the Datastore vs Format rule, a vector DB is a system that persists and indexes data for retrieval, so it is fundamentally a Datastore rather than a Tool or Platform.",
          "skill_id": "vector-db",
          "subtype": "vector_database",
          "type": "Datastore"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "Hybrid Search",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Hybrid Search",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "search_retrieval_pattern",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cHybrid Search\u201d is a specific retrieval pattern (combining lexical + vector). Typical JDs won\u2019t confuse it with other distinct search/IR skills in the catalog."
          },
          "context_keywords": {
            "context_keywords": [
              "vector search",
              "semantic search",
              "information retrieval",
              "natural language processing",
              "machine learning",
              "ranking algorithms",
              "query expansion",
              "relevance feedback",
              "fuzzy matching",
              "data fusion",
              "indexing strategies",
              "search algorithms",
              "knowledge graphs",
              "metadata enrichment",
              "user intent"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Hybrid search appears increasingly in job descriptions for RAG/search roles and is supported by major vendors like Elasticsearch and OpenSearch, but it is not yet a universal hiring staple."
          },
          "skill_id": "hybrid-search",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Retrieval approaches that combine lexical and semantic search signals to improve relevance. Hybrid search belongs here because it typically blends keyword matching with vector similarity, reranking, and query fusion for robust information retrieval.",
            "exemplar_skills": [
              "Hybrid Search",
              "BM25",
              "Vector Search",
              "Dense Retrieval",
              "Sparse Retrieval",
              "Reranking",
              "Query Fusion",
              "Semantic Retrieval"
            ],
            "in_scope": "Hybrid Search, lexical search, BM25, vector search, dense retrieval, sparse retrieval, query fusion, reranking, semantic retrieval, retrieval-augmented generation (RAG) retrieval, Elasticsearch hybrid retrieval, OpenSearch hybrid search, Pinecone hybrid retrieval",
            "name": "Hybrid Search Retrieval",
            "out_of_scope": "Document indexing pipelines, embedding model training, database administration, UI search widgets, recommendation ranking, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Embedding-based retrieval often depends on ML libraries, but this dimension is about retrieval strategy rather than model development.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Hybrid Search",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "hybrid-search"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "embeddings",
            "algorithms",
            "repository-pattern",
            "deep-links",
            "fetch-api",
            "traffic-splitting",
            "feature-modules",
            "splunk"
          ],
          "requires": [],
          "skill_id": "hybrid-search",
          "suppress_on_match": []
        },
        "skill_id": "hybrid-search",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.92,
          "name": "Hybrid Search",
          "reasoning": "Hybrid Search is fundamentally a named retrieval concept/pattern combining multiple search approaches, and it is not a tool, platform, or architecture under the provided disambiguation rules.",
          "skill_id": "hybrid-search",
          "subtype": "search_retrieval_pattern",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "Prompt engineering",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Prompt engineering",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "prompt_engineering",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cPrompt engineering\u201d is a specific, commonly used term for LLM prompting and is unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "fine-tuning",
              "natural language processing",
              "model training",
              "user intent",
              "contextual prompts",
              "prompt design",
              "iterative testing",
              "prompt templates",
              "AI alignment",
              "feedback loops",
              "data annotation",
              "evaluation metrics",
              "prompt optimization",
              "user experience",
              "language models"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "Prompt engineering is increasingly listed in AI/LLM job descriptions and vendor docs, but it\u2019s still not a universal hiring staple like Python or AWS."
          },
          "skill_id": "prompt-engineering",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Designing, refining, and evaluating prompts for large language models and other generative AI systems. This includes instruction phrasing, few-shot examples, output constraints, and iterative prompt debugging to improve reliability and task performance.",
            "exemplar_skills": [
              "Prompt engineering",
              "Prompt design",
              "Few-shot prompting",
              "System prompt writing",
              "Prompt debugging",
              "Prompt evaluation",
              "Structured prompting",
              "Instruction crafting"
            ],
            "in_scope": "Prompt engineering, prompt templates, system prompts, user prompts, few-shot prompting, zero-shot prompting, chain-of-thought prompting, structured output prompting, prompt iteration, prompt debugging, prompt evaluation, prompt versioning, instruction tuning guidance, LLM prompt design",
            "name": "Prompt Engineering",
            "out_of_scope": "Model training and fine-tuning, retrieval pipeline design, agent orchestration, safety policy enforcement, these belong to other AI engineering dimensions",
            "overlap_flags": [
              {
                "reason": "Prompting is often implemented through ML/LLM libraries, but the dimension here is the interaction design rather than the underlying framework APIs.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "Prompts can affect policy and safety outcomes, but compliance review focuses on approval and governance rather than prompt construction.",
                "with_dim_id": "ai-use-case-compliance-review",
                "with_dim_name": null,
                "with_role": "AI Compliance Officer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Prompt engineering",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "prompt-engineering"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "intelligent-automation",
            "mlops",
            "model-versioning",
            "ci-cd",
            "feature-flags",
            "startup-profiling",
            "traffic-splitting"
          ],
          "requires": [],
          "skill_id": "prompt-engineering",
          "suppress_on_match": []
        },
        "skill_id": "prompt-engineering",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Concept: ruled out \u2014 it is not just a knowledge unit but an operational practice for interacting with models."
          ],
          "confidence": 0.93,
          "name": "Prompt engineering",
          "reasoning": "Prompt engineering is fundamentally a way of working for crafting and iterating prompts, so by the Concept vs Methodology rule it fits Methodology rather than a tool or concept.",
          "skill_id": "prompt-engineering",
          "subtype": "prompt_engineering",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "OpenAI",
          "alias_type": "CANONICAL",
          "id": 1822,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "OpenAI",
        "id": 1186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "openai",
        "sub_category_id": 896,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "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": "OpenAI",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "OpenAI",
      "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": "Anthropic",
          "alias_type": "CANONICAL",
          "id": 1824,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Anthropic",
        "id": 1188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "anthropic",
        "sub_category_id": 898,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "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": "Anthropic",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Anthropic",
      "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": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS Bedrock",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS Bedrock",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AWS Bedrock",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Service",
          "skill_nature": "CLOUD_SERVICE",
          "sub_category": "foundation_model_service",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "AWS Bedrock is a specific AWS foundation-model service; typical JDs distinguish it from other AWS AI services."
          },
          "context_keywords": {
            "context_keywords": [
              "foundation models",
              "generative AI",
              "machine learning",
              "SageMaker",
              "API integration",
              "data pipelines",
              "model training",
              "inference",
              "scalability",
              "cloud-native",
              "serverless architecture",
              "data security",
              "real-time analytics",
              "multi-modal",
              "deployment",
              "cost optimization"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "AWS Bedrock is appearing in more job descriptions and vendor docs as teams adopt managed LLM APIs, but it is still far less common than core AWS services like EC2/S3 or Kubernetes in hiring pipelines."
          },
          "skill_id": "aws-bedrock",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Amazon Web Services",
            "year_introduced": 2023
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "cloud-platforms",
            "a_name": "Cloud Platform Services",
            "a_role": "__skill_focal__",
            "b_dim_id": "cloud-provider-platforms",
            "b_name": "Cloud Provider Platforms",
            "b_role": "Cloud Architect",
            "pair_kind": "cross_role",
            "reasoning": "A is hands-on managed cloud services (Bedrock, Lambda, S3, EC2, IAM, SageMaker) for building/operating apps. B is cloud-architecture work: using provider platforms to choose deployment boundaries and target-state designs. The overlap is broad cloud wording, but the exemplar skills point to different work. career-track: no, because a senior AWS services practitioner is not automatically a senior cloud architect.",
            "similarity": 0.6850310016195308
          }
        ],
        "locked_dimensions": [
          {
            "description": "Core managed services offered by major cloud providers for building and operating applications. AWS Bedrock fits here because it is an AWS-managed platform service used by engineers to access foundation models and related AI capabilities.",
            "exemplar_skills": [
              "AWS Bedrock",
              "AWS Lambda",
              "Amazon S3",
              "Amazon EC2",
              "AWS IAM",
              "Amazon SageMaker"
            ],
            "in_scope": "AWS Bedrock, AWS core services, managed compute, storage, networking, IAM, serverless services, cloud service APIs",
            "name": "Cloud Platform Services",
            "out_of_scope": "Infrastructure as Code tools, Kubernetes cluster operations, CI/CD pipelines, on-prem virtualization, vendor-neutral architecture patterns",
            "overlap_flags": [
              {
                "reason": "Bedrock selection may involve evaluating model providers and managed AI service terms, but that dimension focuses on procurement and compliance review rather than platform usage.",
                "with_dim_id": "ai-vendor-and-third-party-due-diligence",
                "with_dim_name": null,
                "with_role": "AI Compliance Officer"
              },
              {
                "reason": "Bedrock is used for model inference and application integration, but not for defining or training ML models in code.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              }
            ],
            "tentative_id": "cloud-platforms"
          },
          {
            "description": "Proficiency in major cloud service provider platforms and their core services.",
            "exemplar_skills": [
              "Cloud Platforms"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cloud Platforms for the target role, including items implied by the dimension rationale.",
            "name": "Cloud Platforms",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cloud Platforms, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cloud-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "AWS Bedrock",
          "placement_confidence": 0.92,
          "primary_dimension": "cloud-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "aws-bedrock"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "aws",
            "amazon-web-services-aws"
          ],
          "related_to": [
            "azure-openai",
            "azure-bicep",
            "aws-ec2",
            "aws-cloudformation",
            "aws-cdk",
            "aws-serverless-application-model-sam",
            "ibm-cloud",
            "azure-blob-storage"
          ],
          "requires": [
            "aws-iam",
            "aws-kms"
          ],
          "skill_id": "aws-bedrock",
          "suppress_on_match": []
        },
        "skill_id": "aws-bedrock",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "AWS Bedrock",
          "reasoning": "By the Platform vs Service rule, AWS Bedrock is a managed capability inside AWS rather than the AWS platform itself, so it is a Service.",
          "skill_id": "aws-bedrock",
          "subtype": "foundation_model_service",
          "type": "Service"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "LangChain",
          "alias_type": "CANONICAL",
          "id": 501,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "LangChain",
        "id": 240,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "langchain",
        "sub_category_id": 146,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "LLM Operations and Orchestration",
            "id": 49,
            "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
            "slug": "llm-operations-and-orchestration",
            "source": "db"
          },
          "input_skill": "LangChain",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "LangChain",
      "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": [
        {
          "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": "DSPy",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "DSPy",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Framework",
          "skill_nature": "FRAMEWORK",
          "sub_category": "llm_programming_framework",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "DSPy is a specific LLM programming framework name; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "data science",
              "machine learning",
              "AI models",
              "programming",
              "pipelines",
              "data preprocessing",
              "model training",
              "evaluation metrics",
              "feature engineering",
              "automated workflows",
              "predictive analytics",
              "data visualization",
              "algorithm optimization",
              "deployment",
              "real-time processing"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "DSPy is appearing in more LLM engineering job descriptions and GitHub adoption is rising, but it is still far from a universal hiring staple like PyTorch or LangChain."
          },
          "skill_id": "dspy",
          "vendor_license": {
            "confidence": 0.9,
            "license": "apache_2",
            "vendor": "Cohere",
            "year_introduced": 2023
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Frameworks and libraries for building, optimizing, and evaluating LLM applications through structured prompts, modules, and programmatic prompt composition. DSPy belongs here because it is a prompt-centric framework for writing and tuning LLM pipelines rather than a general ML model library.",
            "exemplar_skills": [
              "DSPy",
              "prompt engineering",
              "prompt optimization",
              "LLM program composition",
              "few-shot prompting",
              "signature-based prompting"
            ],
            "in_scope": "DSPy, prompt modules, signature-based prompting, prompt optimization, few-shot compilation, LLM pipeline composition, programmatic prompt engineering, retrieval-augmented prompting, evaluation of prompt programs",
            "name": "Prompt Programming Frameworks",
            "out_of_scope": "Core model training and fine-tuning, generic Python application frameworks, vector databases and retrieval infrastructure, cloud deployment tooling, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "DSPy is an ML-adjacent library, but its primary focus is prompt/program construction for LLMs rather than general model definition or training.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "DSPy programs may be evaluated and deployed in ML pipelines, but the framework itself is not a CI/CD system.",
                "with_dim_id": "ci-cd-for-machine-learning",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "DSPy",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "dspy"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "chromadb",
            "apis",
            "typescript",
            "javascript",
            "java",
            "dynamic-type",
            "docker",
            "github"
          ],
          "requires": [],
          "skill_id": "dspy",
          "suppress_on_match": []
        },
        "skill_id": "dspy",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Library: ruled out \u2014 although it is imported like a package, the primary role is to provide a structured application-building framework.",
            "Tool: ruled out \u2014 it is not software operated independently by a user."
          ],
          "confidence": 0.9,
          "name": "DSPy",
          "reasoning": "DSPy is best classified as a Framework because users build applications and LLM pipelines inside it rather than using it as standalone software.",
          "skill_id": "dspy",
          "subtype": "llm_programming_framework",
          "type": "Framework"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Docker",
          "alias_type": "CANONICAL",
          "id": 198,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 654,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Containerization and Image Builds",
            "id": 152,
            "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
            "slug": "containerization-and-image-builds",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Runtime Configuration",
            "id": 13,
            "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
            "slug": "deployment-and-runtime-configuration",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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"
            }
          ]
        }
      ],
      "input_skill": "Docker",
      "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": "Kubernetes",
          "alias_type": "CANONICAL",
          "id": 1267,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.0+",
          "alias_type": "VERSION",
          "id": 1271,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1270,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes v1",
          "alias_type": "VERSION",
          "id": 1269,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "k8s",
          "alias_type": "VERSION",
          "id": 1268,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1400,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes latest",
          "alias_type": "VERSION",
          "id": 1401,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "Kubernetes",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kubernetes",
      "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": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "Redshift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Redshift",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "data_warehouse_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cRedshift\u201d typically refers specifically to Amazon Redshift; it\u2019s unlikely to be confused with other distinct data-warehouse platforms in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "AWS",
              "data lake",
              "SQL",
              "ETL",
              "data modeling",
              "analytics",
              "columnar storage",
              "scalability",
              "performance tuning",
              "data migration",
              "business intelligence",
              "Redshift Spectrum",
              "cluster management",
              "query optimization",
              "data warehousing",
              "Amazon S3"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Amazon Redshift is widely listed in data-warehouse/cloud analytics job descriptions and remains an AWS flagship service; no vendor sunset, and it\u2019s commonly paired with Snowflake/BigQuery rather than replaced."
          },
          "skill_id": "redshift",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Amazon",
            "year_introduced": 2012
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Managed cloud data warehouse services used for analytical storage, SQL querying, and large-scale reporting. Redshift belongs here because it is an AWS-managed warehouse platform for storing and analyzing structured data.",
            "exemplar_skills": [
              "Redshift",
              "Amazon Redshift",
              "Redshift Serverless",
              "Redshift COPY command",
              "distribution keys",
              "sort keys"
            ],
            "in_scope": "Redshift, Amazon Redshift clusters, Redshift Serverless, SQL analytics on warehouse data, columnar storage, distribution keys, sort keys, workload management, data loading with COPY",
            "name": "Cloud Data Warehousing Platforms",
            "out_of_scope": "Operational AWS compute, networking, and storage primitives not specific to warehousing, ETL orchestration, BI dashboarding, streaming ingestion, on-prem databases",
            "overlap_flags": [
              {
                "reason": "Redshift is an AWS-managed service and may also be discussed as part of broader cloud platform knowledge.",
                "with_dim_id": "cloud-provider-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "cloud-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Redshift",
          "placement_confidence": 0.92,
          "primary_dimension": "cloud-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "redshift"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "splunk",
            "prometheus",
            "datadog",
            "sentry",
            "rag",
            "chromadb",
            "cilium",
            "blue-green-deployment"
          ],
          "requires": [],
          "skill_id": "redshift",
          "suppress_on_match": []
        },
        "skill_id": "redshift",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 although Redshift is a managed capability, the vendor SaaS rule treats the commercial hosted environment as a Platform rather than a Service.",
            "Datastore: ruled out \u2014 it persists data, but the primary classification here is the hosted managed environment rather than just a storage engine."
          ],
          "confidence": 0.93,
          "name": "Redshift",
          "reasoning": "By the Vendor SaaS = Platform rule, Amazon Redshift is a hosted multi-tenant managed analytics environment with APIs rather than software you run yourself, so it fits Platform.",
          "skill_id": "redshift",
          "subtype": "data_warehouse_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "RDS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "RDS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Service",
          "skill_nature": "CLOUD_SERVICE",
          "sub_category": "managed_relational_database_service",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "rds_aws"
            ],
            "reasoning": "\u201cRDS\u201d is commonly used for AWS Relational Database Service; could be extracted as a specific AWS RDS skill vs a generic RDS entry."
          },
          "context_keywords": {
            "context_keywords": [
              "AWS",
              "Aurora",
              "PostgreSQL",
              "MySQL",
              "SQL Server",
              "database migration",
              "scalability",
              "high availability",
              "backup and restore",
              "multi-AZ",
              "read replicas",
              "performance tuning",
              "security groups",
              "parameter groups",
              "cloudformation"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "AWS RDS is a standard managed database service and appears frequently in cloud/DevOps job descriptions alongside PostgreSQL/MySQL on AWS, indicating broad hiring-pipeline adoption."
          },
          "skill_id": "rds",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Amazon Web Services",
            "year_introduced": 2009
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Managed database services offered by cloud providers for relational storage, scaling, backups, and high availability. RDS belongs here because it commonly refers to Amazon Relational Database Service, a core managed database platform in cloud engineering.",
            "exemplar_skills": [
              "RDS",
              "Amazon RDS",
              "RDS backups",
              "RDS Multi-AZ",
              "RDS read replicas",
              "RDS parameter groups"
            ],
            "in_scope": "RDS, Amazon Relational Database Service, managed MySQL and PostgreSQL instances, backups and snapshots, Multi-AZ deployments, read replicas, parameter groups, storage scaling, maintenance windows",
            "name": "Cloud Database Services",
            "out_of_scope": "Self-managed database tuning on EC2 or Kubernetes, application ORM usage, data modeling, and query optimization belong to database engineering or application architecture rather than the managed service itself",
            "overlap_flags": [
              {
                "reason": "RDS is often provisioned and configured through IaC tools, but the service knowledge itself is about managed cloud databases.",
                "with_dim_id": "infrastructure-as-code",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              },
              {
                "reason": "Database changes may be coordinated with release workflows, though that dimension focuses on rollout strategy rather than the database platform.",
                "with_dim_id": "deployment-and-release-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "cloud-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "RDS",
          "placement_confidence": 0.92,
          "primary_dimension": "cloud-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "rds"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "aws",
            "amazon-web-services-aws"
          ],
          "related_to": [
            "managed-databases",
            "sqlite",
            "amazon-ecs",
            "amazon-ec2",
            "amazon-s3",
            "amazon-ebs",
            "amazon-efs",
            "datadog"
          ],
          "requires": [
            "aws-iam",
            "aws-kms",
            "dns"
          ],
          "skill_id": "rds",
          "suppress_on_match": []
        },
        "skill_id": "rds",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "RDS",
          "reasoning": "By the Service vs Platform rule, RDS is a specific managed capability inside AWS rather than the whole hosted environment, so it is a Service.",
          "skill_id": "rds",
          "subtype": "managed_relational_database_service",
          "type": "Service"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "S3",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-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": "S3",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Systems Programming",
            "id": 166,
            "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
            "slug": "d_init_02",
            "source": "db"
          },
          "input_skill": "S3",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "S3",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "cloud_storage_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cS3\u201d in JDs typically refers unambiguously to AWS Simple Storage Service; other common meanings are rare in this context."
          },
          "context_keywords": {
            "context_keywords": [
              "AWS",
              "bucket",
              "object storage",
              "S3 Select",
              "IAM policies",
              "versioning",
              "data lifecycle",
              "multipart upload",
              "transfer acceleration",
              "CloudFormation",
              "event notifications",
              "CORS",
              "encryption",
              "static website hosting",
              "AWS CLI"
            ]
          },
          "maturity": {
            "confidence": 0.98,
            "maturity": "well_known",
            "reasoning": "Amazon S3 is a default cloud storage service in AWS job descriptions and architecture docs; it remains broadly adopted with no vendor sunset, and is commonly paired with S3-compatible storage rather than replaced."
          },
          "skill_id": "s3",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Amazon",
            "year_introduced": 2006
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Managed object storage services used to store, retrieve, and serve files, datasets, backups, and application assets. S3 belongs here because it is the canonical AWS object storage service and is commonly used as foundational cloud storage infrastructure.",
            "exemplar_skills": [
              "S3",
              "Amazon S3",
              "object storage",
              "bucket policies",
              "lifecycle policies",
              "presigned URLs",
              "multipart upload"
            ],
            "in_scope": "S3, Amazon S3 buckets, objects and prefixes, storage classes, lifecycle policies, versioning, bucket policies, presigned URLs, multipart upload, static asset storage",
            "name": "Cloud Storage Services",
            "out_of_scope": "Block storage volumes, file systems, and instance disks, data warehouse tables and query engines, Kubernetes persistent volumes, application-level caching and CDN behavior",
            "overlap_flags": [
              {
                "reason": "S3 often stores sensitive data and may be governed by encryption, access control, and retention requirements.",
                "with_dim_id": "data-security-and-dlp",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              },
              {
                "reason": "S3 is frequently provisioned and managed through IaC templates, but the storage service itself is the core skill.",
                "with_dim_id": "infrastructure-as-code",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              }
            ],
            "tentative_id": "cloud-platforms"
          },
          {
            "description": "Operational use of object storage for durable file and dataset management across applications and pipelines. This fits S3 when the emphasis is on organizing objects, controlling access, and managing storage behavior rather than broader cloud platform knowledge.",
            "exemplar_skills": [
              "S3",
              "Amazon S3",
              "object storage",
              "bucket versioning",
              "lifecycle rules",
              "multipart upload",
              "presigned URL generation"
            ],
            "in_scope": "S3, buckets, objects, prefixes, storage classes, lifecycle rules, versioning, replication, multipart uploads, presigned URLs, event notifications",
            "name": "Object Storage Operations",
            "out_of_scope": "Compute services, networking, IAM policy design beyond storage access, database storage engines, CDN configuration, container storage volumes",
            "overlap_flags": [
              {
                "reason": "Object storage is a core cloud service, so this dimension overlaps with broader cloud platform knowledge.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              },
              {
                "reason": "Access control, encryption, and retention on S3 can intersect with data protection requirements.",
                "with_dim_id": "data-security-and-dlp",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "AWS-specific storage primitives and managed storage offerings used to persist application data and artifacts. S3 belongs here as the primary AWS object storage service and a common integration point for AI and data workflows.",
            "exemplar_skills": [
              "S3",
              "Amazon S3",
              "S3 buckets",
              "S3 lifecycle policies",
              "S3 replication",
              "S3 event notifications",
              "presigned URLs"
            ],
            "in_scope": "S3, Amazon S3, S3 buckets, S3 object keys, S3 storage classes, S3 lifecycle policies, S3 event notifications, S3 replication, S3 presigned URLs",
            "name": "AWS Storage Services",
            "out_of_scope": "Non-AWS cloud storage products, compute and orchestration services, database services, IAM administration outside storage access, analytics engines that read from S3",
            "overlap_flags": [
              {
                "reason": "AWS storage services are a subset of broader cloud provider platform knowledge.",
                "with_dim_id": "cloud-provider-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "This is AWS-specific, while the catalog also has a broader cloud platforms dimension.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              }
            ],
            "tentative_id": "d_init_02"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "S3",
          "placement_confidence": 0.92,
          "primary_dimension": "cloud-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_01",
            "d_init_02"
          ],
          "skill_id": "s3"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "aws"
          ],
          "related_to": [
            "amazon-ebs",
            "amazon-efs",
            "ecs",
            "azure-bicep",
            "splunk",
            "pci-dss",
            "soc-2"
          ],
          "requires": [],
          "skill_id": "s3",
          "suppress_on_match": []
        },
        "skill_id": "s3",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "S3",
          "reasoning": "By the Platform vs Tool rule, S3 is a hosted multi-tenant AWS environment with APIs and managed storage capabilities, so it is a Platform rather than a user-run tool or a datastore product.",
          "skill_id": "s3",
          "subtype": "cloud_storage_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Redis",
          "alias_type": "CANONICAL",
          "id": 168,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Redis",
        "id": 31,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "redis",
        "sub_category_id": 28,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Caching and State Management",
            "id": 7,
            "rationale": "Techniques and systems for reducing latency and managing ephemeral backend state. Covers cache-aside patterns, distributed caches, session stores, and invalidation strategies.",
            "slug": "caching-and-state-management",
            "source": "db"
          },
          "input_skill": "Redis",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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"
            }
          ]
        }
      ],
      "input_skill": "Redis",
      "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": [
        {
          "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": "Vector Search",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Vector Search",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "vector_search",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cVector Search\u201d is a specific retrieval concept (embeddings + similarity) and is unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "embedding",
              "similarity",
              "nearest neighbor",
              "semantic search",
              "ANN",
              "vector database",
              "FAISS",
              "Pinecone",
              "Milvus",
              "cosine similarity",
              "search index",
              "query vector",
              "dimensionality reduction",
              "vector space model",
              "retrieval augmentation"
            ]
          },
          "maturity": {
            "confidence": 0.88,
            "maturity": "emerging",
            "reasoning": "Vector search is increasingly listed in AI/ML and search JDs, and major vendors like Pinecone, Weaviate, and pgvector show strong adoption, but it is not yet a universal hiring staple."
          },
          "skill_id": "vector-search",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Systems and techniques for indexing, storing, and querying embeddings by semantic similarity. Vector Search belongs here because it is the core retrieval mechanism behind embedding-based search, recommendation, and RAG pipelines.",
            "exemplar_skills": [
              "Vector Search",
              "Approximate Nearest Neighbor Search",
              "HNSW",
              "FAISS",
              "Milvus",
              "Pinecone",
              "Weaviate",
              "Qdrant",
              "Hybrid Search"
            ],
            "in_scope": "Vector Search, approximate nearest neighbor search, embedding indexes, similarity search, ANN algorithms, HNSW, IVF, FAISS, Milvus, Pinecone, Weaviate, Qdrant, Elasticsearch vector search, hybrid lexical-plus-vector retrieval",
            "name": "Vector Search Systems",
            "out_of_scope": "Traditional keyword search and inverted indexes, embedding model training and fine-tuning, database transaction design, full-text relevance tuning without vectors, model serving and inference APIs",
            "overlap_flags": [
              {
                "reason": "Vector search often consumes embeddings produced by ML frameworks, but the retrieval/indexing layer is a distinct concern.",
                "with_dim_id": "ml-frameworks-and-libraries",
                "with_dim_name": null,
                "with_role": "ML Engineer"
              },
              {
                "reason": "Production vector systems may track embedding provenance and index metadata, but lineage is not the primary skill cluster.",
                "with_dim_id": "data-lineage-and-metadata",
                "with_dim_name": null,
                "with_role": "Data Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Vector Search",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "vector-search"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "algorithms"
          ],
          "related_to": [
            "sqlite",
            "firebase-firestore",
            "fetch-api",
            "jvm",
            "javascript",
            "location-services",
            "splunk",
            "background-fetch"
          ],
          "requires": [],
          "skill_id": "vector-search",
          "suppress_on_match": []
        },
        "skill_id": "vector-search",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Architecture: ruled out \u2014 it can be part of a system design, but the skill name itself is the underlying retrieval concept.",
            "Tool: ruled out \u2014 no specific software product is named that a user would run."
          ],
          "confidence": 0.78,
          "name": "Vector Search",
          "reasoning": "Vector Search is best treated as a Concept because it names a retrieval approach/technique rather than a specific product, runtime, or system you operate.",
          "skill_id": "vector-search",
          "subtype": "vector_search",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Git",
          "alias_type": "CANONICAL",
          "id": 1613,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Git",
        "id": 1002,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "git",
        "sub_category_id": 730,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "Git",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Git",
      "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": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "Azure DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "Azure DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Azure DevOps",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "devops_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAzure DevOps\u201d is a specific Microsoft DevOps suite; typical JDs won\u2019t confuse it with other CI/CD platforms like Jenkins or GitHub Actions."
          },
          "context_keywords": {
            "context_keywords": [
              "Azure Pipelines",
              "Terraform",
              "GitHub Actions",
              "Docker",
              "Kubernetes",
              "Agile",
              "Continuous Integration",
              "Continuous Deployment",
              "Infrastructure as Code",
              "Release Management",
              "Monitoring",
              "Version Control",
              "Service Hooks",
              "Work Items",
              "Build Agents"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Azure DevOps appears in many enterprise job descriptions for CI/CD, boards, and repos, and Microsoft continues active product support and updates; it remains a common hiring-pipeline skill alongside GitHub Actions/Jenkins."
          },
          "skill_id": "azure-devops",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Microsoft",
            "year_introduced": 2018
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Systems used to define, run, and maintain automated build and deployment workflows. Azure DevOps belongs here because it provides pipeline authoring, build agents, release automation, and repo-integrated delivery tooling.",
            "exemplar_skills": [
              "Azure DevOps",
              "Azure Pipelines",
              "YAML pipelines",
              "release pipelines",
              "build agents",
              "pipeline templates",
              "artifact feeds",
              "branch policies"
            ],
            "in_scope": "Azure DevOps, Azure Pipelines, build pipelines, release pipelines, YAML pipeline definitions, self-hosted agents, pipeline variables, pipeline templates, artifact publishing, approvals and checks, branch policies",
            "name": "CI/CD Pipeline Platforms",
            "out_of_scope": "Cloud infrastructure provisioning and environment topology, which belong to infrastructure as code or cloud governance, application release strategy and rollout policy, which belong to deployment and release patterns, runtime observability and incident response, which belong to observability and incident triage",
            "overlap_flags": [
              {
                "reason": "Azure DevOps often implements release gates and promotion workflows, but the release strategy itself is owned by deployment and release patterns.",
                "with_dim_id": "deployment-and-release-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "Azure DevOps can orchestrate IaC execution, but the declarative provisioning tools and cloud definitions belong to infrastructure as code.",
                "with_dim_id": "infrastructure-as-code",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              }
            ],
            "tentative_id": "ci-cd-pipeline-platforms"
          },
          {
            "description": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "exemplar_skills": [
              "CI/CD Pipeline Platforms"
            ],
            "in_scope": "Skills, tools, and practices that belong under CI/CD Pipeline Platforms for the target role, including items implied by the dimension rationale.",
            "name": "CI/CD Pipeline Platforms",
            "out_of_scope": "Adjacent clusters explicitly not owned by CI/CD Pipeline Platforms, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "ci-cd-pipeline-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Azure DevOps",
          "placement_confidence": 0.92,
          "primary_dimension": "ci-cd-pipeline-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "azure-devops"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "microsoft-azure"
          ],
          "related_to": [
            "azure-devops-pipelines",
            "ci-cd",
            "github-actions",
            "gitlab-ci",
            "gitlab",
            "github"
          ],
          "requires": [],
          "skill_id": "azure-devops",
          "suppress_on_match": []
        },
        "skill_id": "azure-devops",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Tool: ruled out \u2014 it is primarily consumed as a hosted SaaS offering, not self-hosted software."
          ],
          "confidence": 0.93,
          "name": "Azure DevOps",
          "reasoning": "By the Platform vs Tool rule, Azure DevOps is a hosted multi-tenant environment with APIs and managed services rather than software you run yourself.",
          "skill_id": "azure-devops",
          "subtype": "devops_platform",
          "type": "Platform"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Agile",
          "alias_type": "CANONICAL",
          "id": 868,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "Agile",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agile",
      "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": [
        {
          "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": "Scrum",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Scrum",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "agile_project_management_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cScrum\u201d is a specific Agile framework; typical JDs distinguish it from other methodologies like Kanban or XP."
          },
          "context_keywords": {
            "context_keywords": [
              "sprint",
              "backlog",
              "scrum master",
              "product owner",
              "daily standup",
              "retrospective",
              "burndown chart",
              "user stories",
              "increment",
              "velocity",
              "Kanban",
              "Agile",
              "story points",
              "definition of done",
              "release planning"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Scrum appears in a large share of software PM/Agile job descriptions and is a standard certification/topic in hiring pipelines, indicating broad market adoption."
          },
          "skill_id": "scrum",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Scrum is an agile delivery framework for planning, coordinating, and inspecting work in iterative increments. It belongs here because it defines team ceremonies, roles, and backlog-driven execution rather than a technical implementation skill.",
            "exemplar_skills": [
              "Scrum",
              "Sprint Planning",
              "Daily Standups",
              "Sprint Retrospective",
              "Sprint Review",
              "User Stories",
              "Story Points"
            ],
            "in_scope": "Scrum, sprint planning, daily standups, sprint review, sprint retrospective, product backlog, sprint backlog, user stories, story points, scrum master, product owner, agile ceremonies",
            "name": "Agile Scrum Practices",
            "out_of_scope": "Kanban flow management, SAFe program coordination, technical project estimation, software architecture, CI/CD automation, which belong to other delivery or engineering dimensions",
            "overlap_flags": [
              {
                "reason": "Scrum often coordinates delivery work, but CI/CD covers the automation systems used to build and deploy software.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "Scrum may schedule releases, but release patterns own the technical rollout and rollback strategies.",
                "with_dim_id": "deployment-and-release-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Scrum",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "scrum"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ci-cd",
            "kubernetes",
            "docker",
            "jenkins",
            "github-actions",
            "git",
            "gitlab",
            "redux"
          ],
          "requires": [],
          "skill_id": "scrum",
          "suppress_on_match": []
        },
        "skill_id": "scrum",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.99,
          "name": "Scrum",
          "reasoning": "By the Concept vs Methodology rule, Scrum is a way of working and managing work rather than a knowledge unit or system shape, so it is a Methodology.",
          "skill_id": "scrum",
          "subtype": "agile_project_management_methodology",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "DevOps",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "devops_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cDevOps\u201d is a widely used, distinct methodology term; typical JDs won\u2019t confuse it with other specific catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "CI/CD",
              "Docker",
              "Kubernetes",
              "Terraform",
              "Ansible",
              "Jenkins",
              "GitOps",
              "Microservices",
              "Infrastructure as Code",
              "Monitoring",
              "Agile",
              "Continuous Integration",
              "Continuous Deployment",
              "Cloud-native",
              "SRE",
              "Automation"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "DevOps appears in a large share of software and platform engineering job descriptions, often alongside CI/CD, Kubernetes, and cloud tooling; it is a standard hiring-pipeline keyword rather than a niche specialty."
          },
          "skill_id": "devops",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "ci-cd-pipeline-platforms",
            "a_name": "CI/CD Pipeline Platforms",
            "a_role": "__skill_focal__",
            "b_dim_id": "infrastructure-as-code",
            "b_name": "Infrastructure as Code",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is about delivery automation platforms for build/test/deploy workflows, with exemplars like Jenkins, GitHub Actions, GitLab CI, Azure DevOps Pipelines, and CircleCI. Dim B is about declarative provisioning of cloud infrastructure and environment standards, i.e. infrastructure-as-code used by cloud architects to express reference architectures and guardrails. These are adjacent but distinct clusters: a senior CI/CD pipeline engineer is not naturally a senior IaC/cloud-architecture practitioner, because the daily work, tools, and outputs differ (release pipelines vs provisioning/guardrails). career-track: no, because CI/CD pipeline operations and infrastructure provisioning/architecture are different seniority tracks and toolchains.",
            "similarity": 0.5859219522777903
          },
          {
            "a_dim_id": "ci-cd-pipeline-platforms",
            "a_name": "CI/CD Pipeline Platforms",
            "a_role": "__skill_focal__",
            "b_dim_id": "deployment-and-release-patterns",
            "b_name": "Deployment and Release Patterns",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A covers CI/CD tooling/platforms (Jenkins, GitHub Actions, GitLab CI, Azure DevOps Pipelines, CircleCI) for defining and running build/test/deploy workflows. Dim B covers release strategy patterns like rollout, rollback, and release gating across environments. These are related but distinct: one is the pipeline system, the other is the deployment policy/patterns used within or alongside it. career-track: no, because a senior pipeline-platform engineer is not automatically a senior release-pattern/cloud-architecture practitioner.",
            "similarity": 0.5961096771720586
          },
          {
            "a_dim_id": "deployment-and-release-patterns",
            "a_name": "Deployment and Release Patterns",
            "a_role": "__skill_focal__",
            "b_dim_id": "deployment-and-release-patterns",
            "b_name": "Deployment and Release Patterns",
            "b_role": "Cloud Architect",
            "pair_kind": "cross_role",
            "reasoning": "Both mention safe promotion across environments, but A is DevOps execution: blue-green deployment, canary release, rolling deployment, feature flags, rollback strategy, progressive delivery, release gates. B is Cloud Architect governance: defining rollout/rollback/release-gating patterns so teams deploy consistently across the platform. career-track: no, because a senior DevOps release engineer is not naturally a senior Cloud Architect setting platform-wide deployment standards.",
            "similarity": 0.898855860796747
          },
          {
            "a_dim_id": "deployment-and-release-patterns",
            "a_name": "Deployment and Release Patterns",
            "a_role": "__skill_focal__",
            "b_dim_id": "deployment-rollouts-and-release-control",
            "b_name": "Deployment Rollouts and Release Control",
            "b_role": "ML Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Overlap is mostly generic release vocabulary. Dim A is DevOps release mechanics: blue-green deployment, canary release, rolling deployment, feature flags, progressive delivery across environments. Dim B is ML model release control: promoting models, version pinning, and rollout strategies for production behavior changes. career-track: no, because a senior software release/DevOps engineer is not naturally a senior ML model deployment engineer; the systems and failure modes differ.",
            "similarity": 0.7080469957293217
          }
        ],
        "locked_dimensions": [
          {
            "description": "Systems used to define, run, and maintain automated build, test, and deployment workflows. DevOps work commonly centers on these delivery pipelines and the tooling that operationalizes software changes.",
            "exemplar_skills": [
              "DevOps",
              "Jenkins",
              "GitHub Actions",
              "GitLab CI",
              "Azure DevOps Pipelines",
              "CircleCI",
              "pipeline-as-code"
            ],
            "in_scope": "DevOps, Jenkins, GitHub Actions, GitLab CI, Azure DevOps Pipelines, CircleCI, build automation, test automation, deployment jobs, pipeline-as-code",
            "name": "CI/CD Pipeline Platforms",
            "out_of_scope": "Cloud account design, network topology, and policy guardrails, which belong to cloud governance and landing zones; runtime scaling and service scheduling, which belong to container orchestration platforms",
            "overlap_flags": [
              {
                "reason": "CI/CD platforms often implement rollout and promotion logic, but the release strategy itself is owned by deployment patterns.",
                "with_dim_id": "deployment-and-release-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "Pipeline failures and broken deployments may require recovery skills beyond normal pipeline authoring.",
                "with_dim_id": "release-troubleshooting-and-recovery",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "ci-cd-pipeline-platforms"
          },
          {
            "description": "Declarative provisioning and environment definition tools used to codify cloud infrastructure and repeatable platform setup. DevOps often includes IaC because it automates the environments that delivery pipelines deploy into.",
            "exemplar_skills": [
              "DevOps",
              "Terraform",
              "CloudFormation",
              "Pulumi",
              "Ansible",
              "drift detection",
              "state management"
            ],
            "in_scope": "DevOps, Terraform, CloudFormation, Pulumi, Ansible, environment provisioning, declarative infrastructure, modules, state management, drift detection",
            "name": "Infrastructure as Code",
            "out_of_scope": "Application build orchestration and test execution, which belong to CI/CD pipeline platforms; cluster scheduling and workload placement, which belong to container orchestration platforms",
            "overlap_flags": [
              {
                "reason": "IaC is often used to implement landing zones, but governance and account structure are the primary concern there.",
                "with_dim_id": "cloud-governance-and-landing-zones",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "IaC provisions services on cloud platforms, but the cloud provider ecosystem itself is a separate dimension.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              }
            ],
            "tentative_id": "infrastructure-as-code"
          },
          {
            "description": "Patterns for promoting software safely across environments, including rollout, rollback, gating, and release coordination. DevOps frequently includes these operational release practices because they govern how changes reach production.",
            "exemplar_skills": [
              "DevOps",
              "blue-green deployment",
              "canary release",
              "rolling deployment",
              "feature flags",
              "rollback strategy",
              "progressive delivery"
            ],
            "in_scope": "DevOps, blue-green deployment, canary release, rolling deployment, feature flags, rollback strategy, release gates, progressive delivery, environment promotion",
            "name": "Deployment and Release Patterns",
            "out_of_scope": "Pipeline authoring and build orchestration, which belong to CI/CD pipeline platforms; incident response and environment repair after failure, which belong to release troubleshooting and recovery",
            "overlap_flags": [
              {
                "reason": "Release patterns are frequently implemented inside CI/CD systems, but the strategy itself is distinct from the platform.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "Rollback and recovery actions can overlap during failed releases, but recovery focuses on diagnosing and fixing broken environments.",
                "with_dim_id": "release-troubleshooting-and-recovery",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "deployment-and-release-patterns"
          },
          {
            "description": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "exemplar_skills": [
              "Infrastructure as Code"
            ],
            "in_scope": "Skills, tools, and practices that belong under Infrastructure as Code for the target role, including items implied by the dimension rationale.",
            "name": "Infrastructure as Code",
            "out_of_scope": "Adjacent clusters explicitly not owned by Infrastructure as Code, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "infrastructure-as-code"
          },
          {
            "description": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "exemplar_skills": [
              "CI/CD Pipeline Platforms"
            ],
            "in_scope": "Skills, tools, and practices that belong under CI/CD Pipeline Platforms for the target role, including items implied by the dimension rationale.",
            "name": "CI/CD Pipeline Platforms",
            "out_of_scope": "Adjacent clusters explicitly not owned by CI/CD Pipeline Platforms, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "ci-cd-pipeline-platforms"
          },
          {
            "description": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "exemplar_skills": [
              "Deployment and Release Patterns"
            ],
            "in_scope": "Skills, tools, and practices that belong under Deployment and Release Patterns for the target role, including items implied by the dimension rationale.",
            "name": "Deployment and Release Patterns",
            "out_of_scope": "Adjacent clusters explicitly not owned by Deployment and Release Patterns, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "deployment-and-release-patterns"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "DevOps",
          "placement_confidence": 0.92,
          "primary_dimension": "ci-cd-pipeline-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 6 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "infrastructure-as-code",
            "deployment-and-release-patterns"
          ],
          "skill_id": "devops"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ci-cd"
          ],
          "related_to": [
            "mlops",
            "infrastructure-as-code",
            "blue-green-deployment",
            "kubernetes",
            "docker",
            "jenkins",
            "github-actions",
            "gitlab-ci"
          ],
          "requires": [],
          "skill_id": "devops",
          "suppress_on_match": []
        },
        "skill_id": "devops",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "DevOps",
          "reasoning": "DevOps is fundamentally a way of working that combines development and operations practices, so by the Concept vs Methodology rule it is a Methodology.",
          "skill_id": "devops",
          "subtype": "devops_methodology",
          "type": "Methodology"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:43-\u003e6"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 1826,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CI/CD",
      "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": [
        {
          "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": "IAM",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "IAM",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "identity_and_access_management_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "IAM (Identity and Access Management) is a standard, specific security domain; typical JDs won\u2019t confuse it with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "SAML",
              "OAuth",
              "OpenID Connect",
              "MFA",
              "RBAC",
              "ABAC",
              "SSO",
              "directory services",
              "identity federation",
              "user provisioning",
              "access control",
              "audit logs",
              "policy management",
              "security tokens",
              "IAM governance"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "IAM is a standard cloud/security platform skill; it appears routinely in AWS/Azure/GCP job descriptions and is a core control in vendor docs and compliance frameworks, indicating broad hiring demand."
          },
          "skill_id": "iam",
          "vendor_license": {
            "confidence": 0.9,
            "license": "proprietary",
            "vendor": "Amazon Web Services",
            "year_introduced": 2011
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Controls for defining identities, roles, permissions, and access policies across systems. IAM belongs here because it is the core discipline for authenticating principals and authorizing what they can do.",
            "exemplar_skills": [
              "IAM",
              "identity and access management",
              "role-based access control",
              "attribute-based access control",
              "single sign-on",
              "multi-factor authentication",
              "privileged access management",
              "access policy design"
            ],
            "in_scope": "IAM, identity providers, roles and groups, permissions, policy evaluation, least privilege, SSO, MFA, service accounts, access reviews, privilege escalation controls",
            "name": "Identity and Access Management",
            "out_of_scope": "Application login UX and token storage, which belong to authentication-and-session-handling; cloud account structure and org-wide guardrails, which belong to cloud-governance-and-landing-zones; data loss prevention and content controls, which belong to data-security-and-dlp",
            "overlap_flags": [
              {
                "reason": "IAM often overlaps with sign-in and session flows, but that dimension is about client-side authentication mechanics rather than enterprise authorization policy.",
                "with_dim_id": "authentication-and-session-handling",
                "with_dim_name": null,
                "with_role": "Android Engineer, Frontend Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Cloud landing zones may define org-level access boundaries, but IAM is the dedicated identity and permission model.",
                "with_dim_id": "cloud-governance-and-landing-zones",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "Access controls can protect sensitive data, but DLP focuses on preventing data leakage rather than identity and authorization management.",
                "with_dim_id": "data-security-and-dlp",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "IAM",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "iam"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "aws-iam",
            "google-cloud-iam",
            "pci-dss",
            "mtls",
            "dns",
            "apis",
            "idempotent-configuration"
          ],
          "requires": [],
          "skill_id": "iam",
          "suppress_on_match": []
        },
        "skill_id": "iam",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "IAM",
          "reasoning": "By the Vendor SaaS = Platform rule, IAM here is best treated as a hosted identity and access management environment with APIs rather than a local tool, since it denotes the managed access-control platform capability.",
          "skill_id": "iam",
          "subtype": "identity_and_access_management_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Observability and Incident Triage",
            "id": 155,
            "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
            "slug": "observability-and-incident-triage",
            "source": "db"
          },
          "input_skill": "Monitoring",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Observability and Incident Triage",
            "id": 155,
            "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
            "slug": "observability-and-incident-triage",
            "source": "db"
          },
          "input_skill": "Monitoring",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Monitoring",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "observability_monitoring",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cMonitoring\u201d in observability/incident triage is a common, specific concept and is unlikely to be confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Prometheus",
              "Grafana",
              "ELK Stack",
              "alerting",
              "metrics",
              "logging",
              "tracing",
              "SLO",
              "SLI",
              "observability",
              "incident response",
              "health checks",
              "anomaly detection",
              "dashboards",
              "monitoring as code"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Monitoring is a standard requirement in most SRE/DevOps job descriptions and is bundled into major platforms like AWS CloudWatch, Datadog, and Prometheus, indicating broad market adoption."
          },
          "skill_id": "monitoring",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "observability-and-incident-triage",
            "a_name": "Observability and Incident Triage",
            "a_role": "__skill_focal__",
            "b_dim_id": "observability-and-incident-triage",
            "b_name": "Observability and Incident Triage",
            "b_role": "DevOps Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Dim A covers production observability for unhealthy systems: monitoring metrics dashboards, logs, traces, health checks, SLOs, anomaly detection, and on-call triage. Its exemplars (Monitoring, Observability, Alerting, Metrics dashboards, Log analysis, Distributed tracing) are runtime diagnosis skills. Dim B targets DevOps delivery observability for failed builds, broken deployments, and unhealthy release environments, i.e. finding where the CI/CD workflow failed. career-track: no, because a senior live-service observability/incident-triage practitioner is not naturally a senior build/deployment pipeline reliability specialist.",
            "similarity": 0.7856498794438364
          }
        ],
        "locked_dimensions": [
          {
            "description": "Telemetry, alerting, and troubleshooting practices used to detect and diagnose unhealthy systems. Monitoring belongs here because it is the core activity of watching metrics, logs, and traces to spot issues and drive response.",
            "exemplar_skills": [
              "Monitoring",
              "Observability",
              "Alerting",
              "Metrics dashboards",
              "Log analysis",
              "Distributed tracing"
            ],
            "in_scope": "Monitoring, metrics dashboards, alerting thresholds, logs, traces, health checks, SLOs, anomaly detection, on-call triage",
            "name": "Observability and Incident Triage",
            "out_of_scope": "Crash analytics and client-side telemetry for mobile apps, release rollback procedures, and postmortem governance, which belong to other operational dimensions",
            "overlap_flags": [
              {
                "reason": "Monitoring often feeds release failure diagnosis, but that dimension focuses on remediation and recovery actions after an incident is detected.",
                "with_dim_id": "release-troubleshooting-and-recovery",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "Both can involve tracking system behavior, but lineage is about data provenance rather than operational health monitoring.",
                "with_dim_id": "data-lineage-and-metadata",
                "with_dim_name": null,
                "with_role": "Data Engineer"
              }
            ],
            "tentative_id": "observability-and-incident-triage"
          },
          {
            "description": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
            "exemplar_skills": [
              "Observability and Incident Triage"
            ],
            "in_scope": "Skills, tools, and practices that belong under Observability and Incident Triage for the target role, including items implied by the dimension rationale.",
            "name": "Observability and Incident Triage",
            "out_of_scope": "Adjacent clusters explicitly not owned by Observability and Incident Triage, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "observability-and-incident-triage"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Monitoring",
          "placement_confidence": 0.92,
          "primary_dimension": "observability-and-incident-triage",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "monitoring"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "opentelemetry",
            "datadog",
            "sentry",
            "retention-schedule-assessment",
            "notification-actions",
            "autoscaling",
            "rolling-update",
            "rollback-automation"
          ],
          "requires": [],
          "skill_id": "monitoring",
          "suppress_on_match": []
        },
        "skill_id": "monitoring",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Monitoring",
          "reasoning": "Monitoring is fundamentally a knowledge unit about observing system health and behavior, so it fits the Concept category rather than a Tool or Platform under the provided rules.",
          "skill_id": "monitoring",
          "subtype": "observability_monitoring",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "Load Balancing",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "Load Balancing",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Load Balancing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Architecture",
          "skill_nature": "PATTERN",
          "sub_category": "traffic_distribution_architecture",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cLoad Balancing\u201d in JDs typically refers to distributing traffic across instances; it\u2019s distinct from other architecture skills in the catalog."
          },
          "context_keywords": {
            "context_keywords": [
              "HAProxy",
              "Nginx",
              "F5",
              "traffic management",
              "round robin",
              "failover",
              "sticky sessions",
              "DNS load balancing",
              "application delivery",
              "scalability",
              "high availability",
              "reverse proxy",
              "session persistence",
              "distributed systems",
              "cloud load balancing"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Load balancing is a standard architecture requirement in cloud and infra JDs, commonly listed alongside AWS, Kubernetes, and NGINX/HAProxy for production traffic distribution."
          },
          "skill_id": "load-balancing",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "deployment-and-release-patterns",
            "a_name": "Deployment and Release Patterns",
            "a_role": "__skill_focal__",
            "b_dim_id": "deployment-and-release-patterns",
            "b_name": "Deployment and Release Patterns",
            "b_role": "Cloud Architect",
            "pair_kind": "cross_role",
            "reasoning": "Dim A is about runtime traffic distribution and load-balancing mechanics: its description mentions distributing traffic across instances/environments, and exemplars include Load Balancing, weighted routing, health checks, blue-green traffic shifting, canary traffic splitting, session affinity, and L4/L7 balancing. Dim B is about cloud release governance: its description focuses on promoting changes safely across environments, including rollout, rollback, and release gating strategies. These overlap in safe deployment, but A is implementation-level traffic shaping while B is process/policy-level release control. career-track: no, because a senior load-balancing/traffic-routing engineer is not naturally a senior cloud release-governance architect.",
            "similarity": 0.7662691105109892
          }
        ],
        "locked_dimensions": [
          {
            "description": "Patterns for distributing traffic safely across application instances and environments during rollout and steady-state operation. Load balancing belongs here when it is used to spread requests, improve availability, and support controlled release behavior.",
            "exemplar_skills": [
              "Load Balancing",
              "traffic distribution",
              "weighted routing",
              "health checks",
              "blue-green traffic shifting",
              "canary traffic splitting",
              "session affinity"
            ],
            "in_scope": "Load Balancing, traffic distribution, weighted routing, health checks, blue-green traffic shifting, canary traffic splitting, session affinity, L4/L7 balancing",
            "name": "Deployment and Release Patterns",
            "out_of_scope": "Container orchestration scheduling, pod placement, autoscaling policies, service discovery internals, which belong to container-orchestration-platforms",
            "overlap_flags": [
              {
                "reason": "Kubernetes and similar platforms often implement service load balancing, but the core skill here is traffic distribution rather than workload scheduling.",
                "with_dim_id": "container-orchestration-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              },
              {
                "reason": "Managed cloud load balancers are cloud services, but the underlying skill is the balancing pattern and configuration.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              }
            ],
            "tentative_id": "deployment-and-release-patterns"
          },
          {
            "description": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "exemplar_skills": [
              "Deployment and Release Patterns"
            ],
            "in_scope": "Skills, tools, and practices that belong under Deployment and Release Patterns for the target role, including items implied by the dimension rationale.",
            "name": "Deployment and Release Patterns",
            "out_of_scope": "Adjacent clusters explicitly not owned by Deployment and Release Patterns, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "deployment-and-release-patterns"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Load Balancing",
          "placement_confidence": 0.92,
          "primary_dimension": "deployment-and-release-patterns",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "load-balancing"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "traffic-splitting",
            "autoscaling",
            "dns",
            "blue-green-deployment",
            "rollback-automation",
            "kubernetes",
            "istio",
            "mtls"
          ],
          "requires": [],
          "skill_id": "load-balancing",
          "suppress_on_match": []
        },
        "skill_id": "load-balancing",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Load Balancing",
          "reasoning": "Load balancing is fundamentally a system-shape pattern for distributing traffic across multiple instances, so it fits the Architecture category rather than a tool or concept.",
          "skill_id": "load-balancing",
          "subtype": "traffic_distribution_architecture",
          "type": "Architecture"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "autoscaling",
          "alias_type": "CANONICAL",
          "id": 1406,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "autoscaling",
        "id": 858,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "autoscaling",
        "sub_category_id": 604,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "Autoscaling",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Autoscaling",
      "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": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "ECR",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "ECR",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "container_registry_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "ECR is a specific, commonly referenced AWS service name (Elastic Container Registry), unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Docker",
              "containerization",
              "Kubernetes",
              "image repository",
              "CI/CD",
              "artifact management",
              "registry authentication",
              "Helm",
              "microservices",
              "cloud-native",
              "DevOps",
              "container orchestration",
              "security scanning",
              "versioning",
              "API integration"
            ]
          },
          "maturity": {
            "confidence": 0.92,
            "maturity": "well_known",
            "reasoning": "Amazon ECR is a standard AWS container registry; it appears frequently in cloud/platform job descriptions and is the default registry in many Kubernetes/ECS deployment stacks."
          },
          "skill_id": "ecr",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Amazon",
            "year_introduced": 2015
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Managed registry services used to store, version, scan, and distribute container images and related artifacts. ECR belongs here because it is AWS\u0027s container registry used by build and deployment workflows.",
            "exemplar_skills": [
              "ECR",
              "Amazon ECR",
              "container image registry",
              "image repository management",
              "container image scanning",
              "registry access policies"
            ],
            "in_scope": "ECR, Amazon ECR, container image repositories, image push and pull, repository policies, image scanning, lifecycle policies, private registry access, OCI artifacts, AWS registry auth",
            "name": "Cloud Container Registry Services",
            "out_of_scope": "Kubernetes cluster scheduling and runtime operations, CI/CD pipeline authoring, general AWS compute services, artifact repositories for non-container packages, application deployment strategy",
            "overlap_flags": [
              {
                "reason": "ECR is commonly used alongside Kubernetes and other orchestrators, but it is a registry service rather than a scheduling or runtime platform.",
                "with_dim_id": "container-orchestration-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              },
              {
                "reason": "ECR often appears in build and release pipelines, but the core skill is artifact storage and distribution, not pipeline orchestration.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "cloud-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "ECR",
          "placement_confidence": 0.92,
          "primary_dimension": "cloud-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "ecr"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ecs",
            "amazon-ecs",
            "aws-ec2",
            "container-registries",
            "amazon-ebs",
            "amazon-efs"
          ],
          "requires": [],
          "skill_id": "ecr",
          "suppress_on_match": []
        },
        "skill_id": "ecr",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "ECR",
          "reasoning": "By the Platform vs Tool rule, ECR is a hosted, multi-tenant AWS-managed registry service consumed via APIs rather than software you run yourself.",
          "skill_id": "ecr",
          "subtype": "container_registry_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "AKS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "AKS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AKS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "kubernetes_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "AKS is a specific acronym for Azure Kubernetes Service; typical JDs won\u2019t confuse it with other Kubernetes platforms."
          },
          "context_keywords": {
            "context_keywords": [
              "Azure",
              "Kubernetes",
              "containerization",
              "Helm",
              "kubectl",
              "microservices",
              "CI/CD",
              "DevOps",
              "container registry",
              "service mesh",
              "monitoring",
              "scalability",
              "load balancing",
              "network policies",
              "persistent storage"
            ]
          },
          "maturity": {
            "confidence": 0.92,
            "maturity": "well_known",
            "reasoning": "AKS appears frequently in cloud/Kubernetes job descriptions and Microsoft actively markets it as a core Azure service, indicating broad enterprise adoption rather than niche use."
          },
          "skill_id": "aks",
          "vendor_license": {
            "confidence": 0.9,
            "license": "other_open",
            "vendor": "Microsoft",
            "year_introduced": 2018
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Platforms that schedule, scale, and manage containerized workloads across clusters and environments. AKS belongs here because it is Azure\u0027s managed Kubernetes service used to run and operate container workloads.",
            "exemplar_skills": [
              "AKS",
              "Kubernetes",
              "EKS",
              "GKE",
              "node pools",
              "pod scheduling",
              "cluster autoscaling"
            ],
            "in_scope": "AKS, Kubernetes clusters, node pools, pod scheduling, service discovery, autoscaling, cluster upgrades, workload placement, managed control planes",
            "name": "Container Orchestration Platforms",
            "out_of_scope": "Container image build and registry management, Kubernetes network policy design, application deployment scripting, cloud account governance",
            "overlap_flags": [
              {
                "reason": "AKS is an Azure-managed service, so cloud-provider familiarity often overlaps with cluster operations.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, ML Engineer"
              },
              {
                "reason": "AKS deployments frequently involve Kubernetes security controls, but this dimension focuses on the platform itself rather than hardening.",
                "with_dim_id": "container-and-kubernetes-security",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "container-orchestration-platforms"
          },
          {
            "description": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "exemplar_skills": [
              "Container Orchestration Platforms"
            ],
            "in_scope": "Skills, tools, and practices that belong under Container Orchestration Platforms for the target role, including items implied by the dimension rationale.",
            "name": "Container Orchestration Platforms",
            "out_of_scope": "Adjacent clusters explicitly not owned by Container Orchestration Platforms, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "container-orchestration-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "AKS",
          "placement_confidence": 0.92,
          "primary_dimension": "container-orchestration-platforms",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "aks"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [],
          "requires": [],
          "skill_id": "aks",
          "suppress_on_match": []
        },
        "skill_id": "aks",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "AKS",
          "reasoning": "AKS is a vendor-hosted managed Kubernetes environment with APIs and multi-tenancy, so by the Platform vs Tool rule it is a Platform rather than software you run yourself.",
          "skill_id": "aks",
          "subtype": "kubernetes_platform",
          "type": "Platform"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "ACR",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "ACR",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Proficiency in major cloud service provider platforms and their core services.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "ACR",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "ACR",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "container_registry_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "acr_azure_container_registry",
              "acr_aws_cloudfront_origin_request_control"
            ],
            "reasoning": "ACR is a common acronym; in JDs it may refer to Azure Container Registry or other ACR-related services, not uniquely this platform."
          },
          "context_keywords": {
            "context_keywords": [
              "Docker",
              "Kubernetes",
              "containerization",
              "CI/CD",
              "image repository",
              "artifact management",
              "Azure DevOps",
              "Helm",
              "microservices",
              "registry authentication",
              "cloud-native",
              "DevOps",
              "container orchestration",
              "scalability",
              "versioning"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "Azure Container Registry (ACR) is a standard Azure service commonly listed in cloud/container DevOps job descriptions alongside AKS and Docker; Microsoft continues active support and docs, indicating broad market adoption."
          },
          "skill_id": "acr",
          "vendor_license": {
            "confidence": 0.9,
            "license": "other_open",
            "vendor": "Microsoft",
            "year_introduced": 2017
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "d_init_01",
            "a_name": "Azure Container Registry",
            "a_role": "__skill_focal__",
            "b_dim_id": "cloud-platforms",
            "b_name": "Cloud Platforms",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is a specific Azure registry skill: ACR, image tagging/versioning, Helm chart storage, OCI artifacts, geo-replication, and private registry access. Dim B is a broad cloud-platform umbrella covering major provider platforms and core services, with no concrete registry focus. A senior ACR practitioner would not automatically be a senior practitioner in the broader multi-cloud platform cluster. career-track: no, because A is Azure container registry specialization while B is generic cloud-platform proficiency.",
            "similarity": 0.6685097753700325
          }
        ],
        "locked_dimensions": [
          {
            "description": "Azure Container Registry (ACR) is the managed registry used to store, version, and distribute container images and related artifacts in Azure-centric delivery flows. It belongs here because ACR is the specific platform skill, not the broader container orchestration or security domains.",
            "exemplar_skills": [
              "ACR",
              "Azure Container Registry",
              "container image tagging",
              "OCI artifact management",
              "geo-replicated container registry",
              "private registry authentication"
            ],
            "in_scope": "ACR, Azure Container Registry, container image storage, image tagging and versioning, Helm chart storage, OCI artifacts, geo-replication, repository permissions, image retention policies, private registry access",
            "name": "Azure Container Registry",
            "out_of_scope": "Kubernetes workload scheduling and cluster management, container runtime hardening, CI/CD pipeline authoring, cloud account governance, which belong to orchestration, security, pipeline, and governance dimensions",
            "overlap_flags": [
              {
                "reason": "ACR is commonly used alongside Kubernetes and other orchestrators, but it is the registry service rather than the orchestration platform itself.",
                "with_dim_id": "container-orchestration-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect, DevOps Engineer"
              },
              {
                "reason": "ACR supports image access control and scanning-related workflows, which can overlap with container security concerns.",
                "with_dim_id": "container-and-kubernetes-security",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Cloud platforms cover major provider ecosystems and their managed services used to build and operate applications. ACR fits here as an Azure-managed service within the broader cloud platform surface.",
            "exemplar_skills": [
              "ACR",
              "Azure",
              "Azure services",
              "managed cloud services",
              "cloud resource configuration",
              "Azure identity integration"
            ],
            "in_scope": "Azure services, Azure Container Registry, compute, storage, networking, identity integrations, managed platform services, cloud resource organization, service configuration",
            "name": "Cloud Platforms",
            "out_of_scope": "On-premises infrastructure only, generic DevOps tooling, application-level container build logic, which are owned by other platform or delivery dimensions",
            "overlap_flags": [
              {
                "reason": "ACR is a provider-specific Azure service, so it overlaps with the broader cloud provider platform dimension.",
                "with_dim_id": "cloud-provider-platforms",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "cloud-platforms"
          },
          {
            "description": "Proficiency in major cloud service provider platforms and their core services.",
            "exemplar_skills": [
              "Cloud Platforms"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cloud Platforms for the target role, including items implied by the dimension rationale.",
            "name": "Cloud Platforms",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cloud Platforms, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cloud-platforms"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "ACR",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "cloud-platforms"
          ],
          "skill_id": "acr"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [],
          "requires": [],
          "skill_id": "acr",
          "suppress_on_match": []
        },
        "skill_id": "acr",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 although it is a managed capability, the skill name refers to the vendor-hosted registry offering as a whole, which the rules classify as Platform.",
            "Tool: ruled out \u2014 it is not self-hosted software operated locally by the user."
          ],
          "confidence": 0.88,
          "name": "ACR",
          "reasoning": "By the Platform vs Tool rule, ACR (Azure Container Registry) is a hosted, multi-tenant Azure service with APIs rather than software you run yourself, so it fits Platform.",
          "skill_id": "acr",
          "subtype": "container_registry_platform",
          "type": "Platform"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "FastAPI",
    "Databricks",
    "Unity Catalog",
    "Agentic workflows",
    "Vector DB",
    "Hybrid Search",
    "Prompt engineering",
    "AWS Bedrock",
    "DSPy",
    "Redshift",
    "RDS",
    "S3",
    "Vector Search",
    "Azure DevOps",
    "Scrum",
    "DevOps",
    "IAM",
    "Monitoring",
    "Load Balancing",
    "ECR",
    "AKS",
    "ACR"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "AI Engineer",
    "id": 13,
    "rationale": "The primary skills indicate a strong emphasis on AI technologies and cloud-based solutions.",
    "role_archetype": "Engineering role focused on developing AI solutions and infrastructure.",
    "slug": "ai-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "FastAPI",
      "tag": "new"
    },
    {
      "skill": "Django",
      "tag": "in_db"
    },
    {
      "skill": "AWS",
      "tag": "in_db"
    },
    {
      "skill": "Azure",
      "tag": "in_db"
    },
    {
      "skill": "Databricks",
      "tag": "new"
    },
    {
      "skill": "Unity Catalog",
      "tag": "new"
    },
    {
      "skill": "Terraform",
      "tag": "in_db"
    },
    {
      "skill": "CloudFormation",
      "tag": "in_db"
    },
    {
      "skill": "React",
      "tag": "in_db"
    },
    {
      "skill": "Next.js",
      "tag": "in_db"
    },
    {
      "skill": "Tailwind CSS",
      "tag": "in_db"
    },
    {
      "skill": "RAG",
      "tag": "in_db"
    },
    {
      "skill": "Agentic workflows",
      "tag": "new"
    },
    {
      "skill": "Vector DB",
      "tag": "new"
    },
    {
      "skill": "Hybrid Search",
      "tag": "new"
    },
    {
      "skill": "Prompt engineering",
      "tag": "new"
    },
    {
      "skill": "OpenAI",
      "tag": "in_db"
    },
    {
      "skill": "Anthropic",
      "tag": "in_db"
    },
    {
      "skill": "AWS Bedrock",
      "tag": "new"
    },
    {
      "skill": "LangChain",
      "tag": "in_db"
    },
    {
      "skill": "DSPy",
      "tag": "new"
    },
    {
      "skill": "Docker",
      "tag": "in_db"
    },
    {
      "skill": "Kubernetes",
      "tag": "in_db"
    },
    {
      "skill": "Redshift",
      "tag": "new"
    },
    {
      "skill": "RDS",
      "tag": "new"
    },
    {
      "skill": "S3",
      "tag": "new"
    },
    {
      "skill": "Redis",
      "tag": "in_db"
    },
    {
      "skill": "Vector Search",
      "tag": "new"
    },
    {
      "skill": "Git",
      "tag": "in_db"
    },
    {
      "skill": "Azure DevOps",
      "tag": "new"
    },
    {
      "skill": "Agile",
      "tag": "in_db"
    },
    {
      "skill": "Scrum",
      "tag": "new"
    },
    {
      "skill": "DevOps",
      "tag": "new"
    },
    {
      "skill": "CI/CD",
      "tag": "in_db"
    },
    {
      "skill": "IAM",
      "tag": "new"
    },
    {
      "skill": "Monitoring",
      "tag": "new"
    },
    {
      "skill": "Load Balancing",
      "tag": "new"
    },
    {
      "skill": "Autoscaling",
      "tag": "in_db"
    },
    {
      "skill": "ECR",
      "tag": "new"
    },
    {
      "skill": "AKS",
      "tag": "new"
    },
    {
      "skill": "ACR",
      "tag": "new"
    }
  ],
  "persistence": {
    "items": [
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Core server-side languages used to implement backend business logic, integrations, and service internals. This is the primary coding surface for the role across application layers.",
          "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 Engineer",
            "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Cybersecurity 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": 13,
        "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": 13,
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Application Frameworks",
          "id": 2,
          "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
          "slug": "web-application-frameworks",
          "source": "db"
        },
        "dimension_id": 2,
        "input_skill": "Django",
        "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 Engineer",
            "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 9,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "AWS",
        "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 Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Provider Platforms",
          "id": 131,
          "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
          "slug": "cloud-provider-platforms",
          "source": "db"
        },
        "dimension_id": 131,
        "input_skill": "AWS",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Posture Tools",
          "id": 64,
          "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
          "slug": "cloud-security-posture-tools",
          "source": "db"
        },
        "dimension_id": 64,
        "input_skill": "AWS",
        "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": "Cybersecurity Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "Azure",
        "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 Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 188,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Provider Platforms",
          "id": 131,
          "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
          "slug": "cloud-provider-platforms",
          "source": "db"
        },
        "dimension_id": 131,
        "input_skill": "Azure",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 188,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Posture Tools",
          "id": 64,
          "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
          "slug": "cloud-security-posture-tools",
          "source": "db"
        },
        "dimension_id": 64,
        "input_skill": "Azure",
        "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": "Cybersecurity Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 188,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Infrastructure as Code",
          "id": 132,
          "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
          "slug": "infrastructure-as-code",
          "source": "db"
        },
        "dimension_id": 132,
        "input_skill": "Terraform",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 286,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Infrastructure as Code for ML",
          "id": 57,
          "rationale": "Tools for provisioning and managing ML infrastructure resources through code.",
          "slug": "infrastructure-as-code-for-ml",
          "source": "db"
        },
        "dimension_id": 57,
        "input_skill": "Terraform",
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 286,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Infrastructure as Code",
          "id": 132,
          "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
          "slug": "infrastructure-as-code",
          "source": "db"
        },
        "dimension_id": 132,
        "input_skill": "CloudFormation",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 837,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React",
        "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": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "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": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Meta-Frameworks \u0026 SSR",
          "id": 130,
          "rationale": "Frameworks that build on UI libraries to provide routing, server-side rendering, and static site generation.",
          "slug": "meta-frameworks-ssr",
          "source": "db"
        },
        "dimension_id": 130,
        "input_skill": "Next.js",
        "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": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 705,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CSS Architecture and Styling",
          "id": 117,
          "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
          "slug": "css-architecture-and-styling",
          "source": "db"
        },
        "dimension_id": 117,
        "input_skill": "Tailwind CSS",
        "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": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 627,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "RAG",
        "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": 1194,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "OpenAI",
        "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": 1186,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Anthropic",
        "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": 1188,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "LLM Operations and Orchestration",
          "id": 49,
          "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
          "slug": "llm-operations-and-orchestration",
          "source": "db"
        },
        "dimension_id": 49,
        "input_skill": "LangChain",
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 240,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Containerization and Image Builds",
          "id": 152,
          "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
          "slug": "containerization-and-image-builds",
          "source": "db"
        },
        "dimension_id": 152,
        "input_skill": "Docker",
        "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": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Runtime Configuration",
          "id": 13,
          "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
          "slug": "deployment-and-runtime-configuration",
          "source": "db"
        },
        "dimension_id": 13,
        "input_skill": "Docker",
        "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 Engineer",
            "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Container Orchestration Platforms",
          "id": 134,
          "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
          "slug": "container-orchestration-platforms",
          "source": "db"
        },
        "dimension_id": 134,
        "input_skill": "Kubernetes",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 726,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Caching and State Management",
          "id": 7,
          "rationale": "Techniques and systems for reducing latency and managing ephemeral backend state. Covers cache-aside patterns, distributed caches, session stores, and invalidation strategies.",
          "slug": "caching-and-state-management",
          "source": "db"
        },
        "dimension_id": 7,
        "input_skill": "Redis",
        "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 Engineer",
            "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 31,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Git",
        "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": 1002,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Agile",
        "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": 520,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "CI/CD",
        "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": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "CI/CD",
        "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"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Container Orchestration Platforms",
          "id": 134,
          "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
          "slug": "container-orchestration-platforms",
          "source": "db"
        },
        "dimension_id": 134,
        "input_skill": "Autoscaling",
        "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 Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 858,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "FastAPI",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1201,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Databricks",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1202,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Data Lineage and Metadata",
          "id": 28,
          "rationale": "Cataloging, documenting, and tracing how data moves and changes across systems. This dimension supports impact analysis, governance, discoverability, and operational understanding of datasets.",
          "slug": "data-lineage-and-metadata",
          "source": "db"
        },
        "dimension_id": 28,
        "input_skill": "Unity Catalog",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1203,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Unity Catalog",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1203,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Agentic workflows",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1204,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Vector DB",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1205,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Hybrid Search",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1206,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Prompt engineering",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1207,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "AWS Bedrock",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1208,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "DSPy",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1209,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "Redshift",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1210,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "RDS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1211,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "S3",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1212,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "S3",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1212,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Systems Programming",
          "id": 166,
          "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
          "slug": "d_init_02",
          "source": "db"
        },
        "dimension_id": 166,
        "input_skill": "S3",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1212,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Vector Search",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1213,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "Azure DevOps",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1214,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "Scrum",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1215,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "DevOps",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Infrastructure as Code",
          "id": 132,
          "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
          "slug": "infrastructure-as-code",
          "source": "db"
        },
        "dimension_id": 132,
        "input_skill": "DevOps",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Release Patterns",
          "id": 140,
          "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
          "slug": "deployment-and-release-patterns",
          "source": "db"
        },
        "dimension_id": 140,
        "input_skill": "DevOps",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1216,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "IAM",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1217,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Observability and Incident Triage",
          "id": 155,
          "rationale": "Telemetry, alerting, and troubleshooting practices used to diagnose failed builds, broken deployments, and unhealthy release environments. This is a coherent cluster because delivery reliability depends on quickly identifying where the workflow failed.",
          "slug": "observability-and-incident-triage",
          "source": "db"
        },
        "dimension_id": 155,
        "input_skill": "Monitoring",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1218,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Release Patterns",
          "id": 140,
          "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
          "slug": "deployment-and-release-patterns",
          "source": "db"
        },
        "dimension_id": 140,
        "input_skill": "Load Balancing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1219,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "ECR",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1220,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Container Orchestration Platforms",
          "id": 134,
          "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
          "slug": "container-orchestration-platforms",
          "source": "db"
        },
        "dimension_id": 134,
        "input_skill": "AKS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1221,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "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": "ACR",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 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": 1222,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 13,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Proficiency in major cloud service provider platforms and their core services.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "ACR",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "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": "Cybersecurity 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": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1222,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 22,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 28,
    "skipped": 0
  },
  "planner_output": null,
  "run_id": "c2572c5b-9053-41b1-b0ec-8b73981437bd"
}

LLM Calls

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

Loading…