Documenting the vision, research, standards, and tooling behind Naftiko, while aligning with the Naftiko Manifest, helping shape the product road map for Naftiko open-source and commercial software that will shape integrations.

Naftiko has just begun building. We have decided that we want to build out in the open. The Naftiko Manifest, and this documentation will guide what we are building. Within this documenation you will find the open-source standards and tooling that we use for the foundation of Naftiko, and as we do the work to develop capabilities, the framework, engine, and fabric, we encourage you to share, participate, and let us know where else we can get involved across any complimentary community.

The framework, engine, and fabric sections of this documentation are just requirements placeholders for what is currently under development. As the road map comes into focus, and releases emerge we will update these sections. The standards and tooling sections reflect the open-source standards and tooling Naftiko is building on top of, ensuring that we tap into the existing standards and tooling our customers are already using–investing in the open-source ecosystem as we work to contribiute our own commercial open-source standards and tooling.

2 - Capabilities

Capabilities are open-source, declarative, standards-based integrations that are aligned with business outcomes within specific domains, providing what is needed to deliver and automate integrations across a variety of use cases.

Problem

Modern software delivery is buckling under the scale, complexity, and sprawl of the systems we’ve stitched together. We have more APIs, services, data pipelines, and integrations than ever before—but building and connecting systems feels harder, not easier. As organizations push to adopt AI, automate with agents, and leverage years of API investments, our traditional interface designs are hitting their limits. result is a growing sense of strain and fragmentation.

Solution

This is where capabilities enter the conversation. Capabilities are open-source, declarative, standards-based integrations aligned with business outcomes within specific domains. They provide the building blocks needed to deliver and automate integrations across countless internal, partner, and third-party systems. Capabilities help rebalance how we think about and execute integrations across the sprawling ecosystems we depend on.

Thinking

Capabilities start with a mindset shift. Capability thinking moves our focus from APIs, endpoints, and resources to the higher-level business functions that actually matter. Instead of designing around tables or CRUD operations, we design around outcomes. Capabilities become the primary building blocks of a platform—not low-level resources, but clear expressions of what the business can do.

A capability is both human-readable and machine-executable. It explains itself. It carries semantic meaning. It can be composed, automated, reused, governed, and observed. In a world of AI agents, event-driven systems, and interconnected ecosystems, capabilities become the logical unit of work and interaction.

Characteristics

A capability is not just a label. It is a strongly typed, governed, standardized set of artifacts. Mature capabilities have qualities that make them predictable, reusable, and understandable across teams, tools, and domains.

Business-aligned, with intuitive metadata, clear boundaries, and domain language
Human- and machine-readable, discoverable, and semantically meaningful
Composable and reusable, interoperable with other capabilities
Declarative, event-driven, automated, and predictable
Governed, policy-driven, secure, role-aware, and monitored
Executable, shareable, versioned, and lifecycle-aware
Integrated across APIs, data connections, file systems, and protocols
Collaborative, bringing product, engineering, and domain experts together
Insightful, observable, and traceable everywhere they run

Properties

These are some of the properties currently being explored to help shape what a capability might be, exploring what is needed across conversations with different companies, as well as beginning to define what capabilities we will need to operate Naftiko. Taking a schema-first and declarative approach to shaping what we are capable of as we are developing the framework and engine to run them, and the fabric to bring it together.

naftiko - A place to track administrative items required.
- schema - A reference to the schema for a capability.
info - A place to put all the metadata and info required.
- name - A plain language name for a capability.
- description - A paragraph description of what a capability does.
- icon - A URL for an image to represent what a cpability does.
- tags - Keywords and phrases that describe what a capability does.
- jsonLd - A JSON-LD reference for capability semantics.
- pinned - Determines whether a capability is pinned or not.
- featured - Determines whether a capability is featured or not.
useCase - A reference to a use case object for a capability.
stakeholders - All of the people involved with a capability.
capabilities - References to other child capabilities.
events - References to CloudEvents objects for capability.
change - The place where all changes are being logged.
- state - Defining the state of a cpability.
- schemaVersion - The version of the capability schema used.
- capabilityVersion - The version of the capability itself.
- updated - When the capability was last updated.
- created - When the capability was created.
source - Information about capability source control.
- httpUrl - The HTTP url to the capability Git repository.
- sshUrl - The SSH url to the capability Git repository.
- dockertHub - The HTTP url to the capability Docker image.
support - Any information regarding the support of a capability.
- issues - A url to where issues can be found for capability.
- discussions - A url to where discussions can be found for capability.
- slack - A url to Slack account or thread for a capability.
license - The licensing applied to a capability.
- data - The license for the data.
- code - The license for the code.
- api - The license for the API.
standards - References to any standards being used to support capability.
services - Referneces to any services being used to support capability.
observability - Any resources regarding the observability of a capability.
- visibility - Whether a capability is public or private.

These are all just proposed properties for a capability based upon the handful of capabilities we have mocked up from the variety of conversations we are having with companies, and will continue to change and evolve based upon feedback and road map priorities.

Examples

These are some of the current capabilities being iterated upon which are being driven by conversations with different companies, and used to inform the schema and this documentation for what a capability is.

API Reusability - Being capable of reusing APIs.
Manage Events - Being capable of managing conference, meetings, and other events.

Links

Some other references regarding what a capability is and can be, based upon ecosystem conversations.

Naftiko Discussions - A dedicated conversation on discussion forum about what a capability can be, engaging with the community.
Capoability Schema - A current draft JSON Schema and examples to define what a capability can be in a governed way.
What is an API Capability - This is a story in an ongoing series to drive a conversation about what a capability is.

3 - Framework

Open-source, industrial-grade development framework for managing integrations across multiple patterns and protocols, providing you with what you need to execute capabilities as part of your existing infrastructure.

Problem

Doing business today requires a diverse data and API integration toolbox, requiring teams to have an increasing number of skills when it comes to performing even simple integrations and automation across the increasing sprawl of internal and 3rd-party APIs being used to power applications. Organizations face:

Integration Complexity - Each API and data source requires custom code, specialized knowledge, and ongoing maintenance
Tool Fragmentation - Teams juggle multiple frameworks, libraries, and platforms to handle different integration patterns
Deployment Overhead - Moving from development to production requires significant containerization and orchestration effort
Testing Challenges - Mocking dependencies and testing integrations remains time-consuming and error-prone
Skill Gaps - Finding developers proficient across diverse integration technologies becomes increasingly difficult

Solution

The Naftiko framework brings an open-source, industrial-grade approach to managing a diverse range of integrations effortlessly, helping simplify and abstract away unnecessary complexity, while meeting developers where they already are working, leveraging a GitOps approach to development. By defining integrations through declarative models rather than imperative code, teams can:

Accelerate Development - Generate fully-functional integration components from models, eliminating boilerplate code
Standardize Patterns - Apply consistent integration patterns across REST, GraphQL, messaging, and data pipelines
Streamline Deployment - Leverage pre-built container packaging that works seamlessly with existing CI/CD workflows
Improve Quality - Utilize built-in mocking and testing capabilities powered by the same models that drive production code
Reduce Maintenance - Update integrations by modifying models rather than refactoring code across multiple repositories

Features

These are the current proposed features of the Naftiko framework, providing what is needed for developers to develop, execute, and iterate upon capabilities using their existing development environment, providing the basic features they need to consistentlky deliver capabilities at scale.

Model-Driven Development - Define integrations using declarative models that describe what you want to accomplish rather than how to accomplish it. The framework automatically generates optimized integration code, API clients, data transformations, and testing artifacts from these models. This approach reduces development time by up to 70% while ensuring consistency across your integration landscape. Models serve as living documentation that stays synchronized with implementation, making onboarding and maintenance significantly easier.
Container Packaging - Every integration component is automatically packaged as a container-ready artifact with optimized resource consumption and startup times. Naftiko generates Dockerfiles, health check endpoints, and configuration management scaffolding that follows container best practices. The framework supports both JVM-based and GraalVM native image compilation, allowing you to choose between fast iteration cycles during development and minimal resource footprint in production.
VSCode Integration - First-class support for Visual Studio Code includes syntax highlighting, model validation, code completion, and inline documentation for Naftiko models. The extension provides real-time feedback as you design integrations, catching errors before generation. One-click generation and local testing capabilities let you validate integrations without leaving your editor. The extension integrates with VSCode’s debugging tools, allowing you to step through generated integration code seamlessly.
IntelliJ Integration - Comprehensive IntelliJ IDEA plugin offering the same model-driven development experience for JetBrains users. The plugin provides advanced refactoring support, visual model designers, and deep integration with IntelliJ’s testing and debugging infrastructure. Navigate seamlessly between models and generated code, with the plugin maintaining traceability between your high-level integration definitions and the underlying implementation.
DockerHub Integration - Pre-built base images and runtime components are available on DockerHub, providing a foundation for your integration containers. These images are regularly updated with security patches and performance optimizations. The framework can push your generated integration containers directly to DockerHub or any OCI-compliant registry as part of your CI/CD pipeline, with automatic tagging and versioning based on your GitOps workflow.
Java Libraries - Extensive collection of Java libraries providing reusable integration components, protocol handlers, data transformers, and utility functions. These libraries handle common integration patterns—retry logic, circuit breakers, rate limiting, caching, and error handling—allowing your models to reference battle-tested implementations rather than requiring custom code. All libraries are designed for high performance and low latency, suitable for demanding production environments.
API Client Generation - Automatically generate type-safe, fully-featured API clients from OpenAPI specifications, GraphQL schemas, or Naftiko models. Generated clients include connection pooling, automatic retry with exponential backoff, request/response logging, and comprehensive error handling. Clients support both synchronous and asynchronous invocation patterns, allowing you to choose the right approach for your use case. Client code is optimized for the underlying HTTP client implementation, ensuring minimal overhead.
API Mocking - Built-in mocking capabilities allow you to generate mock servers directly from your integration models or API specifications. Mock servers simulate realistic API behavior including latency, error conditions, and stateful interactions, enabling comprehensive testing without dependencies on external services. Mocks can be deployed as standalone containers for integration testing or embedded in unit tests for rapid feedback. The mocking engine uses the same Apache Calcite processing layer as production integrations, ensuring behavioral consistency.

As the road map for the Naftiko framework comes into focus for 2026, this list will evolve. This list is meant to drive discussion around what is needed in the ecosystem and help communicate what we are planning as we are doing the work to formalize.

Links

Naftiko Discussion - A dedicated conversation on discussion forum about what the Naftiko Freamework is and can be, engaging with the community along the way.

4 - Engine

Performant and scalable engine for executing capabilities while controlling inbound and outbound traffic, managing encryption, key and token issueing and rotation, rate limiting, and other runtime needs.

Problem

Modern enterprises run on an ever-expanding landscape of APIs, data sources, 3rd party services, and cloud platforms. As this environment grows more distributed and more dynamic, teams need a reliable, unified way to execute business capabilities while handling the operational complexity that comes with integrating internal and external systems.

Solution

The Naftiko Engine is built for exactly this moment—a performant, scalable runtime designed to execute, automate, and govern business capabilities with precision, consistency, and security. Whether you’re powering copilots, agentic automation, internal microservices, or integrations with 3rd-party SaaS solutions, the Naftiko Engine provides the foundation you need.

Features

At its core, the Naftiko Engine is responsible for executing capabilities—business operations exposed through a mix of APIs, event-driven architecture, and data connections. But unlike a traditional API gateway or API consumption engine, it is designed specifically for capability-driven integration, where business semantics, intent, and governance carry as much weight as the API calls being brokered.

Executes internal and external capabilities at scale
Controls inbound and outbound traffic
Manages encryption, key and token issuance, and rotation
Enforces rate limits and quotas
Applies dynamic, personalized data protections
Observes, audits, and reports activity for compliance
Mediates protocols and versions to maintain long-term stability

This is a runtime built for the next decade of automation—not just to move data, but to move business value with the context and governance needed to confidently do business across hundreds of 3rd-party platforms.

Capability-Driven

What makes the Naftiko Engine different isn’t just its runtime—it’s the methodology behind it. Capability-driven integration ensures that teams think in terms of business operations, not raw APIs, data connectors, and other tooling.

The Engine supports this lifecycle through five key phases:

Discover & Learn - Identify your first use case and select the source capabilities you will consume.Understand what exists, what’s missing, and where the value is.
Explore & Create - Explore the catalog of existing capabilities.Create new ones as needed—always aligned to business domains.
Deliver & Govern - Define the external and internal consumption policies.Apply guardrails and governance without blocking innovation.
Mediate & Broker - Version capabilities, add ports and adapters, and mediate protocols.The Engine handles the translation—teams focus on the business need.
Compose & Orchestrate - Design composite capabilities that bring it all together. Consumers (humans, copilots, or agents) define what they need, and the Engine makes it possible.

This flow enables teams to move quickly, safely, and consistently—without reinventing the basics every time a version changes, and when a new integration or automation is required.

Outbound Policies

These are the current proposed outbound API consumption policies being proposed for the Naftiko Engine, standardizing the layer in between your applications, internal systems, and 3rd-party external APIs–getting a handle on all of your outbound traffic.

API Authentication
API Token Refresh
API Rate LImiting
API Budget Management
API Discovery
API Mocking
API Failover
API Scaling
API Consumption Observability
API Consumption Auditing
API Consumption Reporting

Inbound Policies

These are the current proposed inbound API consumption policies being proposed for the Naftiko Engine, standardizing the layer you build your server, desktop, web, mobile, and artificial intelligence applications, and the 3rd-party or internal APIs they consume.

Internal Client Authentication
Internal Client Authorization
Internal Rate Limitation
Internal Quota Management
Personalized Data Masking
Personalized Encryption
Semantic Data Validation
Semantic Data Formatting
Network Management
Conditional Caching

These are the proposed features for the open-source Naftiko Engine and will be changing and evolving as work begins on the engine, and the road map comes into focus for 2026, developing this tooling out in the open based upon what the ecossytem is needing today.

Links

Naftiko Discussion - A dedicated conversation on discussion forum about what the Naftiko Engine is and can be, engaging with the community along the way.
Engine Schema - The draft schema being used to define the configuration of each Naftiko engine.

5 - Fabric

Bringing together the capabilities across your domains into a single fabric that allows you to observe, control, and understand traffic across internal and 3rd-party API consumption across different applications.

Problem

For more than a decade, enterprises have invested heavily in APIs, middleware, and integration platforms—yet AI is revealing the limits of these systems faster than anyone expected. While predictions about AI’s transformative potential grow louder, most organizations still struggle to operationalize even their most promising proofs-of-concept. The gap between AI’s promise and enterprise reality is no longer technical; it’s architectural.

Challenges

AI agents cannot thrive in a world built for static API contracts, brittle scripts, legacy connectors, and manually orchestrated integrations. These tools were designed for a different era—an era of predictable workflows and human-driven interactions—not dynamic, autonomous systems capable of reasoning, planning, and acting. If enterprises want AI to produce real, scalable value, the foundation must evolve.

Failure

Most AI integration efforts rely on wrapping existing APIs with multi-modal prompts, auto-generating MCP endpoints, or leaning on aging iPaaS pipelines and connector SDKs. These approaches may work for demos, but break under real operational pressure:

Connectors are brittle, inconsistent, and rarely secure enough for autonomous execution.
API gateways enforce traffic rules but know nothing about business meaning.
ESBs and iPaaS tools create centralized bottlenecks and mapping spaghetti.
Agent frameworks generate wrappers, not reliable, governed business behaviors.

Enterprises are discovering the painful truth: AI can call APIs, but it cannot operate an enterprise made of APIs. Not without a better substrate.

Capabilities

A Capability is more than an API, function, or connector. It’s a governed, discoverable, composable, observable unit of business function—designed for humans and agents - capabilities elevate traditional APIs by embedding:

Business meaning: semantics, expected outcomes, constraints
Operational guardrails: authentication, masking, cost controls, rate limits
Governed autonomy: safe execution patterns for AI-specific workloads
Polyglot access: REST, events, functions, agent protocols, and MCP
Composability: the ability to build higher-order capabilities from lower-level ones

This shift answers the central question enterprises are grappling with: What is the smallest, safest, most reusable unit of business function an AI agent should be allowed to operate? The answer is Capabilities.

Fabric

When dozens or hundreds of capabilities exist across teams and systems, enterprises need a cohesive way to govern, observe, and compose them. This is where the Capability Fabric emerges—a new architectural pattern purpose-built for AI-era integration.

A Capability Fabric is not a gateway. It is not a service mesh. It is not an ESB. It is not an iPaaS. It is a distributed, domain-aligned, policy-driven coordination layer for autonomous interactions between humans, agents, and systems. Where a gateway handles traffic, where a mesh handles service connectivity, where an ESB handles workflows,the Capability Fabric handles meaning and safe execution.

Domain-level composition aligned with strategic business functions
Layered governance across source, domain, and experience contexts
Operational observability with metrics tied to cost, security, and quality
Policy controls at capability boundaries
AI-ready execution for autonomous agents and multi-modal experiences

It becomes the connective tissue that lets AI actually do work—securely, consistently, and with business alignment.

Web of Capabilities

Once capabilities proliferate within and between organizations, something larger starts to emerge—a new layer of the web. A Web of Capabilities. This is the network the Semantic Web aspired to create but couldn’t achieve, because it lacked:

Executable semantics
Distributed governance
Cross-domain policy
Practical adoption inside enterprises

Capabilities supply the missing ingredients. The Capability Fabric supplies the execution environment. Agents supply the demand. Together, they form an Agentic Web: a global fabric of purposeful, governed, inter-operable business capabilities. This is where Naftiko is focused—not on short-lived AI demos, but on building the architecture that will empower autonomous systems to act safely and meaningfully at scale.

Links

Naftiko Discussion - A dedicated conversation on discussion forum about what the Naftiko Fabric is and can be, engaging with the community along the way.

6 - Services

These are all of the services we are currently supporting when it comes to building capabilities, offering a variety of services to support conversations with different companies, adding new ones as they are requested and needed as part of our ongoing Nafitko Signals work.

6.1 - Anthropic

Claude is an AI assistant created by Anthropic that helps people with a wide variety of tasks through natural conversation. I can assist with writing and editing, answer questions on many topics, help with analysis and research, provide coding support, engage in creative projects, and offer explanations of complex concepts.

Listing: https://contracts.apievangelist.com/store/anthropic/

Repo: https://github.com/api-evangelist/anthropic

APIs

Properties

6.2 - Atlassian

Atlassian is a software company that develops collaboration, productivity, and project management tools to help teams work more efficiently. Its products are designed to enhance teamwork, streamline workflows, and support project tracking across a wide range of industries.

Listing: https://contracts.apievangelist.com/store/atlassian/

Repo: https://github.com/api-evangelist/atlassian

APIs

6.3 - Avalara

Avalara is a tax compliance software company that automates sales tax, VAT, and other transaction taxes for businesses. It calculates the correct tax rates for each transaction based on location and product type across thousands of jurisdictions, then handles tax return filing and compliance monitoring. Businesses use it because sales tax rules are extremely complex and constantly changing, especially when selling across multiple states or online, and Avalara’s automation saves them from having to manually track and comply with thousands of different tax requirements.

Listing: https://contracts.apievangelist.com/store/avalara/

Repo: https://github.com/api-evangelist/avalara

APIs

Avalara

Properties

6.4 - BigCommerce

BigCommerce is a NASDAQ-listed ecommerce platform that provides software as a service services to retailers. The company’s platform includes online store creation, search engine optimization, hosting, and marketing and security from small to Enterprise sized businesses.

Listing: https://contracts.apievangelist.com/store/bigcommerce/

Repo: https://github.com/api-evangelist/bigcommerce

APIs

Properties

6.5 - Cvent

Cvent is a leading event management software company that helps organizations plan, promote, and execute successful events. Their comprehensive platform allows users to easily create event websites, manage registrations, and track attendee engagement. With features such as event budgeting, email marketing, and attendee analytics, Cvent streamlines the event planning process and helps businesses maximize their return on investment. Additionally, their mobile app and on-site check-in tools ensure a seamless experience for both event organizers and attendees. Overall, Cvent empowers organizations to deliver impactful and memorable events that drive business results.

Listing: https://contracts.apievangelist.com/store/cvent/

Repo: https://github.com/api-evangelist/cvent

APIs

Cvent

Properties

6.6 - Datadog

Datadog is a monitoring and analytics platform that helps organizations gain insight into their infrastructure, applications, and services. It allows users to collect, visualize, and analyze real-time data from a variety of sources, including servers, databases, and cloud services. Datadog’s platform enables companies to track performance metrics, troubleshoot issues, and optimize their systems for peak efficiency. With its customizable dashboards and alerting system, Datadog empowers teams to proactively monitor their environments and ensure smooth operations. Ultimately, Datadog helps businesses make data-driven decisions and improve the overall performance of their technology stack.

Listing: https://contracts.apievangelist.com/store/datadog/

Repo: https://github.com/api-evangelist/datadog

APIs

Datadog API

Properties

6.7 - Docker

Docker is a software platform that allows developers to package, distribute, and run applications in containers. Containers are lightweight, standalone, and portable environments that contain everything needed to run an application, including code, runtime, system tools, libraries, and settings. Docker provides a way to streamline the development and deployment process by isolating applications in containers, making it easier to manage dependencies, scale applications, and ensure consistency across different environments. Docker simplifies the process of building, deploying, and managing applications, ultimately leading to increased efficiency and productivity for developers.

Listing: https://contracts.apievangelist.com/store/docker/

Repo: https://github.com/api-evangelist/docker

APIs

Docker

6.8 - Figma

Figma’s mission is to make design accessible to everyone. Our two products help people from different backgrounds and roles express their ideas visually and make things together.

Listing: https://contracts.apievangelist.com/store/figma/

Repo: https://github.com/api-evangelist/figma

APIs

Properties

6.9 - GitHub

GitHub is a cloud-based platform for software development and version control, built on Git. It enables developers to store, manage, and collaborate on code. In addition to Gits distributed version control, GitHub offers access control, bug tracking, feature requests, task management, continuous integration, and wikis for projects. Headquartered in California, it has operated as a subsidiary of Microsoft since 2018.

Listing: https://contracts.apievangelist.com/store/github/

Repo: https://github.com/api-evangelist/github

APIs

Properties

6.10 - Google

Google Cloud APIs are programmatic interfaces to Google Cloud Platform services. They are a key part of Google Cloud Platform, allowing you to easily add the power of everything from computing to networking to storage to machine-learning-based data analysis to your applications.

Listing: https://contracts.apievangelist.com/store/google/

Repo: https://github.com/api-evangelist/google

APIs

Properties

6.11 - Grafana

Grafana is a powerful open-source platform for data visualization and monitoring. It allows users to create interactive, customizable dashboards that display real-time data from multiple sources in a visually appealing way. With Grafana, users can easily connect to databases, cloud services, and other data sources, and then display that data in various chart types, tables, and histograms. Grafana also offers advanced alerting capabilities, enabling users to set up alerts based on specified conditions and thresholds. Overall, Grafana is a versatile tool that helps organizations make sense of their data and monitor the performance of their systems in a centralized, user-friendly interface.

Listing: https://contracts.apievangelist.com/store/grafana/

Repo: https://github.com/api-evangelist/grafana

APIs

Grafana

6.12 - HubSpot

HubSpot is a leading CRM platform that provides software and support to help businesses grow better. Our platform includes marketing, sales, service, and website management products that start free and scale to meet our customers' needs at any stage of growth. Today, thousands of customers around the world use our powerful and easy-to-use tools and integrations to attract, engage, and delight customers.

Listing: https://contracts.apievangelist.com/store/hubspot/

Repo: https://github.com/api-evangelist/hubspot

APIs

Properties

6.13 - Kong

Kong provides the foundation that enables any company to securely adopt AI and become an API-first company speeding up time to market, creating new business opportunities, and delivering superior products and services.

Listing: https://contracts.apievangelist.com/store/kong/

Repo: https://github.com/api-evangelist/kong

APIs

Kong

Properties

6.14 - LinkedIn

LinkedIn is a social networking site for professionals to connect with colleagues, employers, and other professionals. It’s a place to share ideas, information, and opportunities, and to find jobs, research companies, and learn about industry news.

Listing: https://contracts.apievangelist.com/store/linkedin/

Repo: https://github.com/api-evangelist/linkedin

APIs

Properties

6.15 - Mailchimp

Mailchimp’s developer tools provide everything you need to integrate your data with intelligent marketing tools and event-driven transactional email.

Listing: https://contracts.apievangelist.com/store/mailchimp/

Repo: https://github.com/api-evangelist/mailchimp

APIs

Properties

6.16 - Meta

Meta Platforms, Inc., doing business as Meta, and formerly named Facebook, Inc., and TheFacebook, Inc., is an American multinational technology conglomerate based in Menlo Park, California. The company owns and operates Facebook, Instagram, Threads, and WhatsApp, among other products and services.

Listing: https://contracts.apievangelist.com/store/meta/

Repo: https://github.com/api-evangelist/meta

APIs

Properties

6.17 - Microsoft Graph

Microsoft Graph is the gateway to data and intelligence in Microsoft cloud services like Microsoft Entra and Microsoft 365. Use the wealth of data accessible through Microsoft Graph to build apps for organizations and consumers that interact with millions of users.

Listing: https://contracts.apievangelist.com/store/microsoft-graph/

Repo: https://github.com/api-evangelist/microsoft-graph

APIs

Properties

6.18 - New Relic

New Relic is a software analytics company that helps businesses monitor and analyze their applications and infrastructure in real-time. By providing detailed insights into the performance and user experience of their systems, New Relic enables organizations to identify and fix issues quickly, optimize performance, and ultimately deliver better digital experiences to their customers. With a range of products and services, including application performance monitoring, infrastructure monitoring, and synthetic monitoring, New Relic empowers businesses to make data-driven decisions and drive digital transformation.

Listing: https://contracts.apievangelist.com/store/new-relic/

Repo: https://github.com/api-evangelist/new-relic

APIs

New Relic

Properties

6.19 - Notion

Notion is a versatile all-in-one workspace tool that helps individuals and teams organize their tasks, projects, and ideas in a centralized and collaborative platform. With features such as databases, boards, calendars, and documents, Notion allows users to create personalized workflows, track progress, and manage information efficiently. Users can customize their workspace to fit their unique needs, whether it be for project management, note-taking, or knowledge sharing. Notion aims to streamline workflows and enhance productivity by providing a flexible and intuitive platform for organizing and managing projects and information.

Listing: https://contracts.apievangelist.com/store/notion/

Repo: https://github.com/api-evangelist/notion

APIs

Notion API

Properties

6.20 - OpenAI

OpenAI is a research organization that focuses on artificial intelligence (AI) and machine learning. Their mission is to ensure that AI benefits all of humanity, and they work on developing AI technology in a way that is safe and beneficial for society. OpenAI conducts cutting-edge research in fields such as natural language processing, reinforcement learning, and robotics. They also develop and release tools and models that help advance the field of AI and are open-source and accessible to the public. Additionally, OpenAI engages in outreach and advocacy efforts to promote the responsible development and deployment of AI technologies.

Listing: https://contracts.apievangelist.com/store/openai/

Repo: https://github.com/api-evangelist/openai

APIs

Properties

6.21 - Salesforce

Salesforce is a cloud-based customer relationship management (CRM) platform that helps businesses manage and track their interactions with customers and leads. It provides a range of services including sales automation, marketing automation, customer service and analytics. Salesforce allows businesses to store all customer data in one centralized location, making it easier to collaborate and communicate with team members and provide personalized experiences for customers. With Salesforce, businesses can streamline their processes, increase efficiency, and ultimately drive growth and success.

Listing: https://contracts.apievangelist.com/store/salesforce/

Repo: https://github.com/api-evangelist/salesforce

APIs

Salesforce

6.22 - SendGrid

SendGrid is a cloud-based customer communication platform that provides tools for email marketing and transactional email delivery. It helps businesses of all sizes easily create and send emails to their customers, enabling them to build stronger relationships and drive engagement. SendGrid also offers analytics and reporting tools to track the success of email campaigns, as well as features for managing subscriber lists and personalizing emails for targeted communications. Overall, SendGrid’s platform allows businesses to streamline their email marketing efforts and improve their overall communication strategies.

Listing: https://contracts.apievangelist.com/store/sendgrid/

Repo: https://github.com/api-evangelist/sendgrid

APIs

Properties

OpenAPI

6.23 - ServiceNow

ServiceNow is a cloud-based platform that provides a wide range of services for businesses to manage their IT operations, customer service, human resources, and other functions. The platform allows organizations to automate and streamline their workflows, improving efficiency and productivity. ServiceNow offers various applications and modules that help companies track and resolve issues, manage projects, and enhance collaboration among employees. Additionally, ServiceNow provides tools for data analytics, reporting, and monitoring to help businesses make informed decisions and optimize their operations. Overall, ServiceNow helps organizations simplify and improve their processes, leading to better customer satisfaction and business outcomes.

Listing: https://contracts.apievangelist.com/store/servicenow/

Repo: https://github.com/api-evangelist/servicenow

APIs

ServiceNow

Properties

6.24 - Shopify

Shopify is an e-commerce platform that enables businesses to create and operate their online stores. It provides a wide range of tools and features that help merchants manage their inventory, process payments, track shipments, and create customized storefronts. With Shopify, businesses can easily set up their online presence, sell products, and reach customers all over the world. The platform also offers various marketing and analytics tools to help businesses grow and succeed in the competitive online marketplace. Overall, Shopify simplifies the process of building and running an online store, making it a popular choice for businesses of all sizes.

Listing: https://contracts.apievangelist.com/store/shopify/

Repo: https://github.com/api-evangelist/shopify

APIs

Shopify API

Properties

6.25 - Slack

Slack is a cloud-based collaboration tool that brings teams together to work more efficiently and effectively. It allows team members to communicate in real-time through instant messaging, group chats, and video calls. Users can share files, collaborate on projects, and stay organized with task management features. Slack also integrates seamlessly with other tools and services, making it easy for teams to streamline their workflow and stay connected, no matter where they are located. With its user-friendly interface and robust features.

Listing: https://contracts.apievangelist.com/store/slack/

Repo: https://github.com/api-evangelist/slack

APIs

Properties

6.26 - Snowflake

Snowflake is a cloud-based data platform that provides data warehousing, data lake, and data sharing capabilities. It enables organizations to store, process, and analyze large volumes of structured and semi-structured data using SQL, while offering scalability, concurrency, and performance across multiple cloud providers. Snowflake is widely used for analytics, business intelligence, and data collaboration.

Listing: https://contracts.apievangelist.com/store/snowflake/

Repo: https://github.com/api-evangelist/snowflake

APIs

Properties

6.27 - Stripe

Stripe is a technology company that provides a platform for online payment processing. They offer a secure and seamless way for businesses to accept payments from customers, handling transactions in multiple currencies and payment methods. Stripe’s software and APIs make it easy for businesses of all sizes to manage their online payments, track transactions, and analyze their revenue streams. With features such as fraud prevention, subscription billing, and mobile payment options, Stripe is a valuable tool for e-commerce businesses looking to streamline their payment processes and provide a better user experience for their customers.

Listing: https://contracts.apievangelist.com/store/stripe/

Repo: https://github.com/api-evangelist/stripe

APIs

Properties

6.28 - Twilio

Twilio is a cloud communications platform that enables developers to integrate voice, messaging, and video capabilities into their applications. Through its APIs, Twilio allows businesses to easily build and scale communication solutions, such as customer support helplines, appointment reminders, and two-factor authentication services. By partnering with Twilio, organizations can enhance their customer engagement strategies and streamline their communication channels, ultimately driving greater efficiency and customer satisfaction. In essence, Twilio empowers developers to create innovative and personalized communication experiences that connect people in new and meaningful ways.

Listing: https://contracts.apievangelist.com/store/twilio/

Repo: https://github.com/api-evangelist/twilio

APIs

Properties

6.29 - Youtube

The Youtube API provides the ability to retrieve feeds related to videos, users, and playlists. It also provides the ability to manipulate these feeds, such as creating new playlists, adding videos as favorites, and sending messsages. The API is also able to upload videos.

Listing: https://contracts.apievangelist.com/store/youtube/

Repo: https://github.com/api-evangelist/youtube

APIs

Properties

6.30 - Zendesk

Zendesk provides customer service and engagement software that helps businesses manage support tickets, automate workflows, and offer multi-channel supportincluding email, chat, social media, and phonethrough a unified platform.

Listing: https://contracts.apievangelist.com/store/zendesk/

Repo: https://github.com/api-evangelist/zendesk

APIs

Properties

6.31 - Zoom

Zoom is a video conferencing platform that allows users to connect with others through virtual meetings, webinars, and chat features. It enables individuals and businesses to communicate and collaborate remotely, making it easier to work together from different locations. With its user-friendly interface and high-quality audio and video capabilities, Zoom has become a popular tool for businesses, schools, and other organizations to stay connected and productive. Whether it’s hosting a team meeting, conducting a virtual workshop, or catching up with friends and family, Zoom provides a seamless and reliable way to communicate in real-time.

Listing: https://contracts.apievangelist.com/store/zoom/

Repo: https://github.com/api-evangelist/zoom

APIs

7 - Organizations

Naftiko is depends on the work of these organizations when it comes to our open-source core, making the standards they produce important, but also other activities that move forward the open-source ecosystem, central to the Naftiko vision and road map.

7.1 - Cloud Native Computing Foundation (CNCF)

The Cloud Native Computing Foundation (CNCF) is a subsidiary of the Linux Foundation founded in 2015 that serves as a vendor-neutral hub for supporting and hosting fast-growing cloud-native open-source projects like Kubernetes, Prometheus, and Envoy, bringing together developers, end users, and vendors to advance cloud-native computing.

The Cloud Native Computing Foundation (CNCF) is a subsidiary of the Linux Foundation founded in 2015 that serves as a vendor-neutral home for cloud-native open-source projects. The foundation hosts and provides support, oversight, and direction for critical components of modern cloud infrastructure, including flagship projects like Kubernetes, Prometheus, Envoy, and dozens of other tools focused on container orchestration, microservices, observability, service meshes, and application delivery. CNCF brings together the world’s top developers, end users, and vendors—including major public cloud providers, enterprise software companies, and innovative startups—to collaborate on advancing cloud-native technologies. The foundation organizes these projects into three maturity levels: Sandbox (early-stage projects being evaluated), Incubating (growing projects gaining adoption), and Graduated (mature, widely-adopted projects that have demonstrated sustained development and production use).

CNCF’s mission is to make cloud-native computing ubiquitous by fostering a robust ecosystem of tools that help organizations build, scale, and secure modern, containerized applications. Beyond hosting projects, the foundation plays a pivotal role in shaping industry standards and best practices through working groups and special interest groups (SIGs) that develop guidelines, policy frameworks, and hardening standards. CNCF also enhances workforce readiness through certifications such as the Certified Kubernetes Administrator (CKA) and Certified Kubernetes Security Specialist (CKS), ensuring consistent skills development across the industry. The foundation runs major conferences like KubeCon + CloudNativeCon, which serve as gathering points for the cloud-native community to exchange ideas, share innovations, and drive the industry forward.

Website - https://www.cncf.io/

7.2 - IANA

IANA (Internet Assigned Numbers Authority) is the organization responsible for coordinating the global allocation and management of internet protocol resources, including IP addresses, domain name system (DNS) root zones, and protocol parameter registries.

The Internet Assigned Numbers Authority (IANA) is a standards organization that oversees the global coordination of critical Internet resources to ensure the network functions smoothly and reliably. IANA’s primary responsibilities fall into three main categories: managing the DNS root zone (including the delegation of top-level domains like .com, .org, and country code domains), coordinating the global allocation of IP addresses and Autonomous System Numbers to Regional Internet Registries, and maintaining protocol parameter registries that define the unique codes and numbering systems used in Internet protocols published as RFCs (Request for Comments). These registries ensure that protocols have globally unique meanings so that computers and networks around the world can communicate effectively with each other.

While the Internet is renowned for being decentralized without central coordination, IANA provides the necessary technical coordination for key elements that must be globally managed to keep the Internet running. IANA works closely with the Internet Engineering Task Force (IETF) to allocate and maintain the unique codes and numbering systems used in technical standards, ensuring that billions of devices can communicate effectively across the Internet. Operating as part of ICANN (Internet Corporation for Assigned Names and Numbers) since 1999, IANA’s work happens behind the scenes every time someone accesses a website, sends an email, or uses any online service—making it possible for devices worldwide to find each other and exchange information reliably and securely.

Website - https://www.iana.org/

7.3 - Internet Engineering Task Force (IETF)

HTTP/3 is the latest HTTP version that runs over QUIC (on UDP), providing multiplexed streams with built-in TLS 1.3 and connection migration to avoid TCP head-of-line blocking and improve performance.

IETF is an open international community of network designers, operators, vendors, and researchers who develop and promote voluntary internet standards, particularly the standards that comprise the Internet Protocol Suite (TCP/IP). The IETF is responsible for creating many of the core technical standards that make the internet work, including protocols like HTTP, TLS/SSL, DNS, and many others.

The IETF operates through working groups that focus on specific areas of internet technology, and their standards are published as RFCs (Requests for Comments). It’s a volunteer-driven organization with no formal membership requirements - anyone interested in internet standards can participate in their work.

Website - https://www.ietf.org/

7.4 - Linux Foundation

The Linux Foundation is a nonprofit organization founded in 2000 that provides a neutral, trusted hub for developers and organizations to code, manage, and scale open source technology projects, supporting approximately 1,000 projects across various industries and delivering tools, training, events, and infrastructure that create an economic impact not achievable by any single company.

The Linux Foundation is a nonprofit organization founded in 2000 that serves as a neutral, trusted hub for developers and organizations to collaborate on open source technology projects. While originally focused on promoting the Linux operating system, the Foundation has evolved into what it calls a “foundation of foundations,” now supporting approximately 1,000 open source projects across software, hardware, standards, and data initiatives in diverse industries including cloud computing, networking, embedded systems, automotive, energy, and more. The Foundation provides essential infrastructure and services that enable these projects to thrive, including project governance frameworks, legal support, trademark and domain management, marketing, event hosting, and financial administration. With over 1,800 company members, the Linux Foundation brings together developers, vendors, and end users to collaborate on solving complex technology problems through shared investment in open source.

Beyond hosting projects, the Linux Foundation provides comprehensive training and certification programs to equip developers with essential skills in open source technologies, holds over 250 events worldwide annually (including major conferences like KubeCon and Open Source Summit), and offers free foundational courses to make technology education more accessible. The Foundation operates on principles of organizational neutrality—ensuring that no single company can control or take away community assets—and maintains a clear separation between financial support and technical participation, meaning that funding doesn’t grant companies the ability to steer technical direction without contributing code. As Executive Director Jim Zemlin describes it, the Linux Foundation acts as “the supporting cast or janitors of open source,” handling all the necessary infrastructure, legal, financial, and administrative work so that developers can focus on writing code and building innovative solutions that deliver economic impact impossible for any single organization to achieve alone.

Website - https://www.ietf.org/

7.5 - World Wide Web Consortium (W3C)

The World Wide Web Consortium (W3C) is an international public-interest nonprofit organization founded in 1994 by web inventor Tim Berners-Lee that develops open standards and guidelines to help build a web based on the principles of accessibility, internationalization, privacy, and security, ensuring the long-term growth and interoperability of the World Wide Web.

The World Wide Web Consortium (W3C) develops technical standards and guidelines for web technologies that ensure the web remains open, accessible, secure, and interoperable for all users worldwide. W3C creates the standards that define how websites and web applications function, including foundational technologies like HTML (Hypertext Markup Language), CSS (Cascading Style Sheets), XML (Extensible Markup Language), and protocols such as HTTP. These standards provide a framework that ensures consistency across browsers, devices, and operating systems, enabling websites and applications to function seamlessly regardless of platform. Through a transparent, consensus-driven process involving member organizations, full-time staff, and public participation, W3C works to foster compatibility and agreement among industry members in adopting new standards, preventing the fragmentation that could occur if different vendors offered incompatible versions of web technologies.

Beyond core web development standards, W3C addresses critical aspects of the modern web including accessibility (through guidelines like WCAG that make the web usable for people with disabilities), internationalization (ensuring the web works in every language and writing system), privacy, and security (developing authentication technologies and standards to enhance user privacy and secure communications). The organization operates through various working groups where external experts collaborate to develop standards that go through rigorous stages of development—from working drafts to candidate recommendations to final W3C Recommendations—ensuring that standards undergo extensive review and testing under both theoretical and practical conditions. W3C’s work ensures a fair and accessible web where developers can have confidence in the tools they’re using, knowing they’ve been vetted by experts, while users experience consistent, high-quality web applications that work across all platforms and devices.

Website - https://www.w3.org/

8 - Standards

Naftiko is standards-first, working with the standards you already use—and those your SaaS providers use—while giving you a framework to maximize common standards and connect the dots across your operational domains.

8.1 - OpenAPI

The OpenAPI Specification (OAS) is a formal standard for describing HTTP APIs. It enables teams to understand how an API works and how multiple APIs interoperate, generate client code, create tests, apply design standards, and more.

Describing the surface area of HTTP APIs and Webhooks.

The OpenAPI Specification (OAS) is a formal standard for describing HTTP APIs. It enables teams to understand how an API works and how multiple APIs interoperate, generate client code, create tests, apply design standards, and more.

OpenAPI was formerly known as Swagger. In 2015, SmartBear donated the specification to the Linux Foundation, establishing the OpenAPI Initiative (OAI) and a formal, community-driven governance model that anyone can participate in.

An OpenAPI document can be written in JSON or YAML and typically defines elements such as: Info, Contact, License, Servers, Components, Paths and Operations, Parameters, Request Bodies, Media Types and Encoding, Responses, Callbacks, Examples, Links, Headers, Tags, Schemas, and Security.

OpenAPI has an active GitHub organization, blog, LinkedIn page, and Slack channel to encourage community participation. In addition, OAI membership helps fund projects and events that drive awareness and adoption.

The OpenAPI Specification can be used alongside two other OAI specifications: (1) the Arazzo specification for defining API-driven workflows, and (2) OpenAPI Overlays, which allow additional information to be overlaid onto an OpenAPI document.

License: Apache

Tags: HTTP APIs, Webhooks

Properties: Info, Contact, License, Servers, Components, Paths and Operations, Parameters, Request Bodies, Media Types and Encoding, Responses, Callbacks, Examples, Links, Headers, Tags, Schemas, and Security

Website: https://www.openapis.org

8.2 - OpenAPI Overlays

The Overlay Specification is an auxiliary standard that complements the OpenAPI Specification. An OpenAPI description defines API operations, data structures, and metadata—the overall shape of an API. An Overlay lists a series of repeatable changes to apply to a given OpenAPI description, enabling transformations as part of your API workflows.

Define metadata, operations, and data structures for overlaying on top of OpenAPI.

The Overlay Specification is an auxiliary standard that complements the OpenAPI Specification. An OpenAPI description defines API operations, data structures, and metadata—the overall shape of an API. An Overlay lists a series of repeatable changes to apply to a given OpenAPI description, enabling transformations as part of your API workflows.

OpenAPI Overlays emerged from the need to adapt APIs for varied use cases, from improving developer experience to localizing documentation. The first version was recently released, and the roadmap is being developed within the OpenAPI Initiative.

The specification provides three constructs for augmenting an OpenAPI description: Info, Overlays, and Actions. How these are applied is being worked out across different tools and industries to accommodate the diversity of APIs being delivered.

To get involved, participate via the GitHub repository, where you’ll find discussions, meeting notes, and related topics. There’s also a dedicated channel within the broader OpenAPI Initiative Slack.

OpenAPI Overlays offer a robust way to manage the complexity of producing and consuming APIs across industries, regions, and domains. As the specification matures, it presents a strong opportunity to ensure documentation, mocks, examples, code generation, tests, and other artifacts carry the right context for different situations.

License: Apache License

Tags: Overlays

Properties: info, overlays, and actions

Website: https://spec.openapis.org/overlay/v1.0.0.html

Standards: JSON Schema

8.3 - Arazzo

The Arazzo Specification is a community-driven, open standard within the OpenAPI Initiative (a Linux Foundation Collaborative Project). It defines a programming-language-agnostic way to express sequences of calls and the dependencies between them to achieve a specific outcome.

Describing your business processes and workflows using OpenAPI.

The Arazzo Specification is a community-driven, open standard within the OpenAPI Initiative (a Linux Foundation Collaborative Project). It defines a programming-language-agnostic way to express sequences of calls and the dependencies between them to achieve a specific outcome.

Arazzo emerged from a need identified in the OpenAPI community for orchestration and automation across APIs described with OpenAPI. Version 1 of the specification is available, and work on future iterations is guided by a public roadmap.

With Arazzo, you can define elements such as: Info, Sources, Workflows, Steps, Parameters, Success Actions, Failure Actions, Components, Reusables, Criteria, Request Bodies, and Payload Replacements—providing a consistent approach to delivering a wide range of automation outcomes.

You can engage with the Arazzo community via the GitHub repository for each version and participate in GitHub Discussions to stay current on meetings and interact with the specification’s stewards and the broader community.

Arazzo is the logical layer on top of OpenAPI: it goes beyond documentation, mocking, and SDKs to focus on defining real business workflows that use APIs. Together, Arazzo and OpenAPI help align API operations with the rest of the business.

License: Apache 2.0

Tags: Workflows, Automation

Properties: Info, Source, Workflows, Steps, Parameters, Success Actions, Failure Actions, Components, Reusable, Criterion, Request Bodies, and Payload Replacements

Website: https://spec.openapis.org/arazzo/latest.html

8.4 - AsyncAPI

AsyncAPI is an open-source, protocol-agnostic specification for describing event-driven APIs and message-driven applications. It serves as the OpenAPI of the asynchronous, event-driven world—overlapping with, and often going beyond, what OpenAPI covers.

Describing the surface area of your event-driven infrastructure.

AsyncAPI is an open-source, protocol-agnostic specification for describing event-driven APIs and message-driven applications. It serves as the OpenAPI of the asynchronous, event-driven world—overlapping with, and often going beyond, what OpenAPI covers.

The specification began as an open-source side project and was later donated to the Linux Foundation after the team joined Postman, establishing it as a standard with formal governance.

AsyncAPI lets you define servers, producers and consumers, channels, protocols, and messages used in event-driven API operations—providing a common, tool-friendly way to describe the surface area of event-driven APIs.

To get involved, visit the AsyncAPI GitHub repository and blog, follow the LinkedIn page, tune into the YouTube or Twitch channels, and join the conversation in the community Slack.

AsyncAPI can be used to define HTTP APIs much like OpenAPI, and it further supports multiple protocols such as Pub/Sub, Kafka, MQTT, NATS, Redis, SNS, Solace, AMQP, JMS, and WebSockets—making it useful across many approaches to delivering APIs.

License: Apache

Tags: Event-Driven

Properties: Servers, Producers, Consumers, Channels, Protocols, and Messages

Website: https://www.asyncapi.com

8.5 - APIOps Cycles

APIOps Cycles is a Lean and service design–inspired methodology for designing, improving, and scaling APIs throughout their entire lifecycle. Developed since 2017 and continuously refined through community contributions and real-world projects across industries, APIOps Cycles provides a structured approach to API strategy using a distinctive metro map visualization where stations and lines represent critical aspects of the API lifecycle.

Aligning engineering with products when it comes to APIs.

The method is built around a collection of strategic canvas templates that help teams systematically address everything from customer journey mapping and value proposition definition to domain modeling, capacity planning, and risk assessment. As an open-source framework released under the Creative Commons Attribution–ShareAlike 4.0 license, APIOps Cycles is freely available for anyone to use, adapt, and share, with the complete method consisting of localized JSON and markdown files that power both the official website and open tooling available as an npm package. Whether you’re a developer integrating the method into your products and services, or an organization seeking to establish API product strategy and best practices, APIOps Cycles offers a proven, community-backed approach supported by a network of partners who can provide guidance and expertise in implementing the methodology effectively.

License: Creative Commons Attribution–ShareAlike 4.0

Tags: Products, Operations

Website: https://www.apiopscycles.com/

APIOps Cycles Canvases Outline

Customer Journey Canvas

Persona
Customer Discovers Need
Customer Need Is Resolved
Journey Steps
Pains
Gains
Inputs & Outputs
Interaction & Processing Rules

API Value Proposition Canvas

Tasks
Gain Enabling Features
Pain Relieving Features
API Products

API Business Model Canvas

API Value Proposition
API Consumer Segments
Developer Relations
Channels
Key Resources
Key Activities
Key Partners
Benefits
Costs

Domain Canvas

Selected Customer Journey Steps
Core Entities & Business Meaning
Attributes & Business Importance
Relationships Between Entities
Business, Compliance & Integrity Rules
Security & Privacy Considerations

Interaction Canvas

CRUD Interactions
CRUD Input & Output Models
CRUD Processing & Validation
Query-Driven Interactions
Query-Driven Input & Output Models
Query-Driven Processing & Validation
Command-Driven Interactions
Command-Driven Input & Output Models
Command-Driven Processing & Validation
Event-Driven Interactions
Event-Driven Input & Output Models
Event-Driven Processing & Validation

REST Canvas

API Resources
API Resource Model
API Verbs
API Verb Example

GraphQL Canvas

API Name
Consumer Goals
Key Types
Relationships
Queries
Mutations
Subscriptions
Authorization Rules
Consumer Constraints
Notes / Open Questions

Event Canvas

User Task / Trigger
Input / Event Payload
Processing / Logic
Output / Event Result

Capacity Canvas

Current Business Volumes
Future Consumption Trends
Peak Load and Availability Requirements
Caching Strategies
Rate Limiting Strategies
Scaling Strategies

Business Impact Canvas

Availability Risks
Mitigate Availability Risks
Security Risks
Mitigate Security Risks
Data Risks
Mitigate Data Risks

Locations Canvas

Location Groups
Location Group Characteristics
Locations
Location Characteristics
Location Distances
Location Distance Characteristics
Location Endpoints
Location Endpoint Characteristics

8.6 - Postman Collections

A Postman Collection is a portable JSON artifacts that organizes one or more API requests—plus their params, headers, auth, scripts, and examples—so you can run, share, and automate them in the Postman desktop or web client application. Collections can include folders, collection- and environment-level variables, pre-request and test scripts, examples, mock server definitions, and documentation.

Executable artifact for automating APi requests and responses for testing.

A Postman Collection is a portable JSON artifacts that organizes one or more API requests—plus their params, headers, auth, scripts, and examples—so you can run, share, and automate them in the Postman desktop or web client application. Collections can include folders, collection- and environment-level variables, pre-request and test scripts, examples, mock server definitions, and documentation.

Postman Collections started as a simple way to save and share API requests in the early Postman client (2013), then grew into a formal JSON format with the v1 schema published in 2015. The format then stabilized as v2.0.0 and shortly after as v2.1.0 in 2017, which remains the common export/import version today.

Owner: Postman

License: Apache 2.0

Properties: Metadata, Requests, Scripts, Variables, Authentication, Methods, Headers, URLs, Bodies, Events, Responses

Website: https://postman.com

8.7 - Postman Environments

Postman environments are collections of variables that let you easily switch between different configurations (like development, staging, and production server URLs) without manually changing values throughout your API requests.

Storing variables for running along with Postman Collections.

Postman environments are a powerful feature that allow you to manage different sets of variables for your API testing and development workflow. An environment is essentially a named collection of key-value pairs (variables) that you can switch between depending on your context—such as development, staging, or production. For example, you might have different base URLs, authentication tokens, or API keys for each environment. Instead of manually updating these values in every request when you switch from testing locally to hitting a production server, you can simply select a different environment from a dropdown menu, and all your requests will automatically use the appropriate variables. This makes it much easier to maintain consistency, avoid errors, and streamline your workflow when working across multiple environments or sharing collections with team members.

Owner: Postman

License: Apache 2.0

Properties: Variables, Variable name, Initial value, Current value, Type, Environment Name, Environment ID, Scope, State

Website: https://learning.postman.com/docs/sending-requests/variables/managing-environments/

8.8 - Backstage Software Catalog Format

Backstage’s Software Catalog format is a structured, YAML-based specification that describes software components, services, APIs, resources, and their relationships, enabling teams to discover, document, and manage ownership and lifecycle information in a centralized developer portal.

The core catalog format for the Backstage environment.

The Backstage Software Catalog provides a centralized system for registering, organizing, and discovering software components across an organization. By using a standardized, YAML-based format, it captures metadata such as ownership, dependencies, lifecycle stage, documentation links, and operational context for services, APIs, libraries, and infrastructure resources. This allows teams to understand how systems fit together, who is responsible for them, and how they should be operated, while enabling automation, governance, and consistent developer experiences through a single, searchable developer portal.

Website: https://backstage.io/docs/features/software-catalog/descriptor-format/

8.9 - Bruno Collection

Bruno collections are organized sets of API requests and environments within the Bruno API client, allowing developers to structure, test, and share their API workflows efficiently.

Open source client specification.

Bruno collections are structured groups of API requests, variables, and environments used within the Bruno API client to help developers organize and manage their API workflows. Each collection acts as a self-contained workspace where you can store requests, define authentication, set environment values, document behaviors, and run tests. Designed with a filesystem-first approach, Bruno collections are easy to version-control and share, making them especially useful for teams collaborating on API development or maintaining consistent testing practices across environments.

License: MIT license

Tags: Clients, Executable

Properties: Name, Type, Version, Description, Variables, Environment, Folders, Requests, Auth, Headers, Scripts, Settings

Website: https://www.usebruno.com/

8.10 - Bruno Environment

A Bruno environment is a set of key–value variables that let you switch configurations—such as URLs, tokens, or credentials—so you can run the same API requests across different contexts like development, staging, or production.

A open-source client environment.

A Bruno environment is a configurable set of key–value variables that allows you to run the same API requests across different deployment contexts, such as local development, staging, and production. Environments typically store values like base URLs, authentication tokens, headers, or other parameters that may change depending on where an API is being tested. By separating these values from the requests themselves, Bruno makes it easy to switch contexts, maintain cleaner collections, and ensure consistency when collaborating with others or automating API workflows.

License: MIT license

Tags: Name, Variables, Enabled, Secret, Ephemeral, Persisted Value

Properties: Name, Type, Version, Description, Variables, Environment, Folders, Requests, Auth, Headers, Scripts, Settings

Website: https://www.usebruno.com/

8.11 - Open Collections

A modern, developer-first specification pioneered by Bruno for defining and sharing API collections. Designed for simplicity and collaboration.

Open-source collection format.

The OpenCollection Specification is a format for describing API collections, including requests, authentication, variables, and scripts. This specification enables tools to understand and work with API collections in a standardized way.

License: Apache License

Tags: Collections

Website: https://www.opencollection.com/

8.12 - gRPC

The Agent2Agent (A2A) Protocol is an open standard for communication and interoperability among independent—often opaque—AI agent systems. Because agents may be built with different frameworks, languages, and vendors, A2A provides a common language and interaction model.

Communicating the interoperability between systems using AI agents.

The Agent2Agent (A2A) Protocol is an open standard for communication and interoperability among independent—often opaque—AI agent systems. Because agents may be built with different frameworks, languages, and vendors, A2A provides a common language and interaction model.

License: Apache 2.0

Tags: agents

Properties: client, servers, cards, messages, tasks, part, artifacts, streaming, push notifications, context, etensions, transport, negotiation, authentication, authorization, and discovery for agent automation. A2A has the discovery, network, context

Website: https://a2a-protocol.org/latest/

Standards: JSON-RPC 2.0, gRPC

8.13 - JSON RPC

JSON-RPC is a lightweight, transport-agnostic remote procedure call (RPC) protocol that uses JSON to encode requests and responses. A client sends an object with jsonrpc “2.0”, a method name, optional params (positional or named), and an id; the server replies with either a result or an error (including standardized error codes), and it also supports notifications (no id, no response) and request batching.

Lightweight transport-agnostic remote procedure call protocol.

JSON-RPC is a lightweight, transport-agnostic remote procedure call (RPC) protocol that uses JSON to encode requests and responses: a client sends an object with jsonrpc:“2.0”, a method name, optional params (positional or named), and an id; the server replies with either a result or an error (including standardized error codes), and it also supports notifications (no id, no response) and request batching.

JSON-RPC emerged in the mid-2000s as a community-driven, lightweight RPC protocol using JSON, with an informal 1.0 spec (c. 2005) that defined simple request/response messaging and “notifications” (no reply). A 1.1 working draft (around 2008) tried to broaden and formalize features but never became canonical. The widely adopted JSON-RPC 2.0 specification (2010) simplified and standardized the model—introducing the mandatory “jsonrpc”:“2.0” version tag, clearer error objects, support for both positional and named parameters, and request batching—while remaining transport-agnostic (HTTP, WebSocket, pipes, etc.).

License: Apache License 2.0 or MIT License

Tags: RPC

Properties: methods, parameters, identifier, results, errors, codes, messages, data

Website: https://www.jsonrpc.org/

Forum:** https://groups.google.com/g/json-rpc

8.14 - Model Context Protocol (MCP)

MCP (Model Context Protocol) is an open protocol that standardizes how applications provide context to large language models (LLMs). It offers a consistent way to connect AI models to diverse data sources and tools, enabling agents and complex workflows that link models to the outside world.

Allowing applications to connect to large language models (LLMs).

MCP (Model Context Protocol) is an open protocol that standardizes how applications provide context to large language models (LLMs). It offers a consistent way to connect AI models to diverse data sources and tools, enabling agents and complex workflows that link models to the outside world.

Introduced by Anthropic as an open-source effort, MCP addresses the challenge of integrating AI models with external tools and data. It aims to serve as a universal “USB port” for AI, allowing models to access real-time information and perform actions.

MCP defines concepts and properties such as hosts, clients, servers, protocol negotiation, lifecycle, transports, authorization, resources, prompts, tools, sampling, roots, elicitation, progress, cancellation, errors, and logging—providing a standardized approach to connecting applications with LLMs.

The MCP community organizes around a GitHub repository (with issues and discussions), plus a Discord, blog, and RSS feed to track updates and changes to the specification.

MCP is seeing growing adoption among API and tooling providers for agent interactions. Many related API/AI specifications reference, integrate with, or overlap with MCP—despite the project being an open-source protocol currently stewarded by a single company, which has not been contributed to a foundation.

Owner: Anthropic

License: MIT License

Tags: agents, workflows

Properties: hosts, clients, servers, protocols, negotiation, lifecycle, transports, authorization, resources, prompts, tools, sampling, roots, elicitation, progress, cancellation, errors, logging

Website: https://modelcontextprotocol.io/

Standards: JSON-RPC 2.0, JSON Schema

8.15 - Apache Parquet

Apache Parquet is a columnar storage file format designed for efficient data storage and retrieval in big data processing frameworks, optimizing for analytics workloads by storing data column-by-column rather than row-by-row, which enables compression, encoding, and query performance optimizations.

Compact binary data serialization.

Apache Parquet is a columnar storage file format specifically designed for efficient data storage and processing in big data analytics environments, developed as a collaboration between Twitter and Cloudera in 2013 and now part of the Apache Software Foundation. Unlike traditional row-oriented formats (like CSV or Avro) that store data records sequentially, Parquet organizes data by columns, grouping all values from the same column together in storage. This columnar approach provides significant advantages for analytical workloads where queries typically access only a subset of columns from wide tables—instead of reading entire rows and discarding unneeded columns, Parquet allows systems to read only the specific columns required for a query, dramatically reducing I/O operations and improving query performance. The format also enables highly effective compression since values in the same column tend to have similar characteristics and patterns, allowing compression algorithms like Snappy, Gzip, LZO, and Zstandard to achieve much better compression ratios than they would on mixed-type row data. Parquet files are self-describing, containing schema information and metadata that allow any processing system to understand the data structure without external schema definitions.

Parquet has become the de facto standard for analytical data storage in modern data lakes and big data ecosystems, with native support across virtually all major data processing frameworks including Apache Spark, Apache Hive, Apache Impala, Presto, Trino, Apache Drill, and cloud data warehouses like Amazon Athena, Google BigQuery, Azure Synapse, and Snowflake. The format supports rich data types including nested and repeated structures (arrays, maps, and complex records), making it ideal for storing semi-structured data from JSON or Avro sources while maintaining query efficiency. Parquet’s internal structure uses techniques like dictionary encoding for low-cardinality columns, bit-packing for small integers, run-length encoding for repeated values, and delta encoding for sorted data, all of which contribute to both storage efficiency and query speed. The format includes column statistics (min/max values, null counts) stored in file metadata that enable predicate pushdown—allowing query engines to skip entire row groups or files that don’t contain relevant data based on filter conditions. This combination of columnar organization, advanced encoding schemes, efficient compression, predicate pushdown, and schema evolution support makes Parquet the optimal choice for data warehouse tables, analytical datasets, machine learning feature stores, time-series data, and any scenario where fast analytical queries over large datasets are required, often achieving 10-100x improvements in query performance and storage efficiency compared to row-oriented formats.

License: Apache 2.0

Tags: Data, Serialization, Binary

Properties: Columnar Storage Format, Column-Oriented, Apache Project, Open Source, Twitter-Cloudera Collaboration, Big Data Format, Analytics Optimized, Self-Describing, Schema Embedded, Metadata Rich, Binary Format, Efficient Storage, High Compression, Compression Support, Snappy Compression, Gzip Compression, LZO Compression, Brotli Compression, Zstandard Compression, Uncompressed Option, Column-Level Compression, Encoding Schemes, Dictionary Encoding, Run-Length Encoding, Bit-Packing, Delta Encoding, Delta Binary Packing, Plain Encoding, Byte Stream Split, Hybrid Encoding, Efficient Reads, Selective Column Access, Column Pruning, Projection Pushdown, Predicate Pushdown, Filter Pushdown, Statistics-Based Filtering, Row Group Skipping, Page-Level Statistics, Column Statistics, Min/Max Values, Null Counts, Distinct Counts, Bloom Filters, File-Level Metadata, Row Group Metadata, Column Chunk Metadata, Page Metadata, Schema Evolution, Schema Compatibility, Add Columns, Remove Columns, Rename Columns, Type Evolution, Nested Data Support, Complex Types, Struct Types, Array Types, Map Types, List Types, Repeated Fields, Optional Fields, Required Fields, Hierarchical Data, Semi-Structured Data, JSON Compatible, Avro Compatible, Thrift Compatible, Protocol Buffers Compatible, Rich Data Types, Primitive Types, Boolean Type, Integer Types, INT32, INT64, INT96, Float Type, Double Type, Binary Type, Fixed-Length Binary, String Type, UTF-8 Strings, Decimal Type, Date Type, Time Type, Timestamp Type, UUID Type, Enum Type, Logical Types, Converted Types, Annotation Support, Row Groups, Columnar Chunks, Data Pages, Dictionary Pages, Index Pages, Header Pages, Footer Structure, Magic Number, Version Number, File Format Version, Parquet Format 2.0, Apache Arrow Integration, Arrow Flight, In-Memory Format, Zero-Copy Reads, Memory Mapping, Lazy Loading, Streaming Reads, Batch Reads, Vectorized Processing, SIMD Optimization, CPU Efficiency, I/O Efficiency, Network Efficiency, Query Performance, Fast Scans, Aggregate Performance, Join Performance, Analytical Workloads, OLAP Queries, Data Warehouse Format, Data Lake Format, Cloud Storage Optimized, S3 Optimized, Azure Blob Compatible, Google Cloud Storage Compatible, HDFS Compatible, Object Storage, Distributed Storage, Splittable Files, Parallel Processing, Multi-Threaded Reads, Concurrent Access, Apache Spark Integration, Spark SQL, DataFrame Support, Dataset Support, PySpark Support, Apache Hive Integration, Hive Tables, HiveQL Support, Impala Support, Presto Support, Trino Support, Apache Drill Support, Dremio Support, ClickHouse Support, DuckDB Support, Snowflake Compatible, BigQuery Compatible, Redshift Spectrum, Athena Compatible, Azure Synapse, Databricks Support, EMR Support, Dataproc Compatible, AWS Glue, Data Catalog Integration, Table Format Support, Delta Lake, Apache Iceberg, Apache Hudi, Time Travel, ACID Transactions, Schema Registry, Metastore Integration, Partition Support, Partitioned Tables, Partition Pruning, Bucketing Support, Sorted Data, Clustered Data, Data Organization, File Organization, Directory Structure, Hive Partitioning, Key-Based Partitioning, Date Partitioning, ETL Integration, Data Pipelines, Batch Processing, Stream Processing, Real-Time Analytics, Apache Kafka Integration, Apache Flink Support, Streaming Writes, Micro-Batching, Change Data Capture, Incremental Updates, Upsert Support, Delete Support, Merge Support, Compaction, Small File Problem, File Consolidation, Optimization, Vacuum Operations, Machine Learning, Feature Store, Training Datasets, Model Input, Data Science, Pandas Integration, NumPy Compatible, Scikit-learn, TensorFlow Datasets, PyTorch DataLoader, Jupyter Notebooks, R Support, Julia Support, Command Line Tools, parquet-tools, parquet-cli, File Inspection, Schema Extraction, Row Count, File Size, Compression Ratio, Storage Metrics, Performance Metrics, Benchmark Results, Query Optimization, Cost-Based Optimization, Statistics Collection, Cardinality Estimation, Data Profiling, Data Quality, Data Validation, Type Safety, Schema Validation, Constraint Checking, Business Rules, Programming Language Support, Java Support, Scala Support, Python Support, C++ Support, Go Support, Rust Support, JavaScript Support, .NET Support, Arrow Parquet, PyArrow, FastParquet, parquet-cpp, parquet-mr, parquet-format, Specification, Open Standard, Vendor Neutral, Cross-Platform, Portable Format, Interoperability, Data Exchange, Data Sharing, Data Publishing, Open Data, Public Datasets, Reproducible Research, Version Control Friendly, Git LFS Compatible, Data Versioning, Data Lineage, Provenance Tracking, Audit Trails, Compliance Support, GDPR Compatible, Data Governance, Access Control, Encryption Support, Encryption at Rest, Column Encryption, Transparent Encryption, Security, Authentication, Authorization, Row-Level Security, Column Masking, Data Redaction, PII Protection, Sensitive Data, Anonymization, Pseudonymization, Production Ready, Enterprise Grade, Mission Critical, High Performance, Scalable, Petabyte Scale, Exabyte Scale, Large Datasets, Wide Tables, Deep Nesting, High Cardinality, Low Cardinality, Sparse Data, Dense Data, Time Series Data, Event Data, Log Data, Metrics Data, Sensor Data, IoT Data, Clickstream Data, User Behavior, Transaction Data, Financial Data, Scientific Data, Genomics Data, Weather Data, Geospatial Data, GIS Integration, Location Data, Coordinates, Spatial Queries, Temporal Queries, Historical Data, Archive Format, Cold Storage, Data Retention, Backup Format, Disaster Recovery, Long-Term Storage, Cost Optimization, Storage Savings, Cloud Cost Reduction, Bandwidth Savings, Compute Efficiency, Resource Optimization, Green Computing, Energy Efficient, Carbon Footprint, Sustainability, Industry Standard, Widely Adopted, Battle Tested, Mature Technology, Active Development, Community Support, Documentation, Examples, Tutorials, Best Practices, Design Patterns, Anti-Patterns, Troubleshooting, Debugging, Profiling Tools, Performance Tuning, Optimization Guides, Migration Tools, Conversion Tools, CSV to Parquet, JSON to Parquet, Avro to Parquet, ORC Alternative, Comparison Benchmarks, Format Selection, Use Case Specific, Analytics First, Write Once Read Many, WORM, Append-Only, Immutable Files, Idempotent Writes, Exactly-Once Semantics, Consistency, Durability, Reliability, Fault Tolerance, Error Handling, Data Integrity, Checksum Validation, CRC Checks, Corruption Detection, Self-Healing, Backward Compatible, Forward Compatible, Version Migration, Legacy Support, Modern Format, Future Proof, Ecosystem Integration, Tool Support, BI Tools, Tableau Support, Power BI, Looker, Qlik, Metabase, Superset, Grafana, Monitoring, Observability, Telemetry, Usage Tracking, Access Patterns, Query Patterns, Workload Analysis

Website: https://parquet.apache.org/

8.16 - Avro

Apache Avro is a data serialization system that provides compact binary encoding of structured data along with schema definitions, enabling efficient data exchange and storage with built-in schema evolution capabilities that allow data structures to change over time while maintaining compatibility between different versions.

Compact binary data serialization.

Apache Avro is a data serialization framework developed within the Apache Hadoop project that provides a compact, fast binary data format along with rich data structures and schema definitions. Created by Doug Cutting (the creator of Hadoop) in 2009, Avro addresses the need for efficient data serialization in big data ecosystems where massive volumes of data must be stored and transmitted efficiently. Unlike JSON or XML which use verbose text-based formats, Avro serializes data into a compact binary representation that significantly reduces storage requirements and network bandwidth while maintaining fast serialization and deserialization performance. Avro schemas are defined using JSON, making them human-readable and language-independent, and these schemas travel with the data (either embedded in files or referenced through a schema registry), ensuring that any system can correctly interpret the serialized data without prior knowledge of its structure. This self-describing nature makes Avro particularly valuable in distributed systems where different services written in different languages need to exchange data reliably.

One of Avro’s most powerful features is its robust support for schema evolution, which allows data schemas to change over time without breaking compatibility between producers and consumers of that data. Avro supports both forward compatibility (new code can read old data) and backward compatibility (old code can read new data) through features like default values for fields, optional fields, and union types. This makes it ideal for long-lived data storage and streaming systems where data structures evolve as business requirements change. Avro has become a cornerstone technology in the big data ecosystem, widely used with Apache Kafka for streaming data pipelines (where the Confluent Schema Registry manages Avro schemas), Apache Spark for data processing, Apache Hive for data warehousing, and as the serialization format for Hadoop’s remote procedure calls. Avro supports rich data types including primitive types (null, boolean, int, long, float, double, bytes, string), complex types (records, enums, arrays, maps, unions, fixed), and logical types (decimals, dates, timestamps), and provides code generation capabilities that create type-safe classes in languages like Java, C++, C#, Python, Ruby, and PHP. Its combination of compact binary encoding, strong schema support, language independence, and schema evolution capabilities makes Avro the preferred serialization format for many data-intensive applications, particularly in streaming architectures and data lakes.

License: Apache 2.0

Tags: Data, Serialization, Binary

Properties: Data Serialization System, Binary Format, Compact Encoding, Schema-Based, JSON Schema Definition, Self-Describing Data, Apache Project, Apache Hadoop Ecosystem, Doug Cutting Created, Open Source, Language-Independent, Platform-Independent, Cross-Language Support, Rich Data Structures, Schema Evolution, Forward Compatibility, Backward Compatibility, Full Compatibility, Default Values, Optional Fields, Field Addition, Field Deletion, Field Renaming, Union Types, Schema Resolution, Schema Registry Support, Confluent Schema Registry, Schema Versioning, Schema ID, Schema Discovery, Dynamic Typing, Static Typing, Code Generation, Type-Safe Classes, Java Support, C++ Support, C# Support, Python Support, Ruby Support, PHP Support, JavaScript Support, Perl Support, Haskell Support, Rust Support, Go Support, Primitive Types, Null Type, Boolean Type, Integer Types, Int Type, Long Type, Float Type, Double Type, Bytes Type, String Type, Complex Types, Record Type, Enum Type, Array Type, Map Type, Union Type, Fixed Type, Logical Types, Decimal Type, Date Type, Time Type, Timestamp Type, Duration Type, UUID Type, Nested Structures, Recursive Types, Named Types, Namespace Support, Documentation Fields, Aliases, Order Specification, File Format, Object Container Files, Data Files, Block-Based Storage, Compression Support, Deflate Compression, Snappy Compression, Bzip2 Compression, XZ Compression, Zstandard Compression, Sync Markers, Splittable Files, Hadoop Compatible, MapReduce Compatible, HDFS Storage, Distributed Storage, Big Data Processing, Streaming Data, Apache Kafka Integration, Kafka Serialization, Producer Support, Consumer Support, Apache Spark Integration, Spark SQL, DataFrame Support, Dataset Support, Apache Hive Integration, Hive Tables, Metastore Integration, Apache Flink Support, Apache Storm Integration, Data Pipeline, ETL Processes, Data Lakes, Data Warehousing, Message Queue Format, Event Sourcing, Log Aggregation, RPC Framework, Remote Procedure Calls, IDL Support, Interface Definition, Service Definition, Protocol Definition, Request/Response, Binary Protocol, Efficient Serialization, Fast Deserialization, Low Overhead, Small Payload Size, Network Efficient, Storage Efficient, Memory Efficient, CPU Efficient, Performance Optimized, High Throughput, Low Latency, Scalable, Version Control Friendly, Schema Registry, Centralized Schema Management, Schema Validation, Schema Compatibility Checking, Breaking Change Detection, Migration Support, Data Transformation, Schema Mapping, Type Conversion, Field Mapping, Data Migration Tools, Schema Tools, Command Line Tools, Avro Tools JAR, Schema Validation Tools, File Inspection, Data Inspection, JSON Conversion, Avro to JSON, JSON to Avro, File Reading, File Writing, Stream Processing, Batch Processing, Real-Time Processing, Container Format, Metadata Support, Custom Metadata, User Metadata, Codec Support, Encoding Options, Generic Records, Specific Records, Reflect Records, Dynamic Schema, Runtime Schema, Compile-Time Schema, Type Safety, Null Safety, Missing Field Handling, Extra Field Handling, Type Promotion, Numeric Promotion, String Encoding, UTF-8, Byte Arrays, Binary Data, Large Object Support, Chunked Data, Block Size Configuration, Buffer Management, Memory Allocation, Object Reuse, Object Pooling, Zero-Copy, Direct Buffers, NIO Support, Async IO, Streaming API, Iterator Support, Random Access, Sequential Access, Index Support, Projection Support, Column Pruning, Predicate Pushdown, Filter Support, Query Optimization, Partition Support, Sharding, Distribution, Replication, Fault Tolerance, Data Integrity, Checksum Support, CRC Validation, Error Detection, Error Handling, Exception Handling, Validation Rules, Constraint Enforcement, Business Rules, Industry Standard, Production Ready, Enterprise Grade, Mission Critical, High Availability, Disaster Recovery, Backup Format, Archive Format, Long-Term Storage, Cold Storage, Hot Storage, Warm Storage, Tiered Storage, Cloud Storage Compatible, S3 Compatible, Azure Blob Storage, Google Cloud Storage, Object Storage, Distributed File Systems, Network File Systems, Local File Systems, Database Storage, NoSQL Databases, Document Stores, Column Stores, Key-Value Stores, Time Series Databases, Graph Databases, Search Engines, Elasticsearch Support, Solr Support, Analytics Engines, Data Science, Machine Learning Datasets, Training Data, Feature Storage, Model Serialization, Experiment Tracking, MLflow Integration, Data Versioning, DVC Support, Data Lineage, Data Provenance, Audit Trails, Compliance, GDPR Support, Data Governance, Data Quality, Data Catalog, Metadata Management, Documentation, API Documentation, Schema Documentation, Field Documentation, Type Documentation, Example Data, Sample Files, Test Data, Mock Data, Debugging Tools, Profiling Tools, Performance Monitoring, Metrics Collection, Logging Support, Tracing, Observability, Monitoring Integration, Alerting, Community Support, Active Development, Regular Releases, Bug Fixes, Security Patches, Performance Improvements, Feature Additions, Backward Compatible Releases, Stable API, Mature Technology, Battle Tested, Widely Adopted, Industry Proven, Ecosystem Integration, Tool Support, IDE Plugins, Editor Support, Build Tool Integration, Maven Support, Gradle Support, SBT Support, NPM Packages, PyPI Packages, Package Managers, Dependency Management, Transitive Dependencies, Minimal Dependencies, Lightweight, Portable, Embeddable, Library Form, Framework Integration, Microservices, Service Mesh, Container Support, Docker Compatible, Kubernetes Support, Cloud Native, Serverless Compatible, Lambda Functions, Edge Computing, IoT Data, Sensor Data, Telemetry, Metrics, Events, Notifications, Webhooks, API Responses, Interoperability, Protocol Buffers Alternative, Thrift Alternative, MessagePack Alternative, BSON Alternative, Parquet Complementary, ORC Complementary, Specification, Standard Format, Open Standard, Vendor Neutral, Community Driven

Website: https://avro.apache.org/

8.17 - Agent2Agent

The Agent2Agent (A2A) Protocol is an open standard for communication and interoperability among independent—often opaque—AI agent systems. Because agents may be built with different frameworks, languages, and vendors, A2A provides a common language and interaction model.

Communicating the interoperability between systems using AI agents.

The Agent2Agent (A2A) Protocol is an open standard for communication and interoperability among independent—often opaque—AI agent systems. Because agents may be built with different frameworks, languages, and vendors, A2A provides a common language and interaction model.

License: Apache 2.0

Tags: agents

Properties: client, servers, cards, messages, tasks, part, artifacts, streaming, push notifications, context, etensions, transport, negotiation, authentication, authorization, and discovery for agent automation. A2A has the discovery, network, context

Website: https://a2a-protocol.org/latest/

Standards: JSON-RPC 2.0, gRPC

8.18 - JSON Schema

JSON Schema is a vocabulary for annotating and validating JSON documents. It defines the structure, content, and constraints of data—often authored in either JSON or YAML—and can be leveraged by documentation generators, validators, and other tooling.

Annotating and validating JSON artifacts.

JSON Schema is a vocabulary for annotating and validating JSON documents. It defines the structure, content, and constraints of data—often authored in either JSON or YAML—and can be leveraged by documentation generators, validators, and other tooling.

The specification traces back to early proposals by Kris Zyp in 2007 and has evolved through draft-04, draft-06, and draft-07 to the current 2020-12 release.

JSON Schema provides a rich set of keywords—such as title, description, type, properties, required, additionalProperties, minimum, maximum, exclusiveMinimum, exclusiveMaximum, default, enum, pattern, items, allOf, anyOf, oneOf, not, examples, and $ref—to describe and validate data used in business operations.

To get involved with the community, visit the JSON Schema GitHub organization, subscribe to the blog via RSS, join discussions and meetings in the Slack workspace, and follow updates on LinkedIn.

JSON Schema is a foundational standard used by many other specifications, tools, and services. It’s the workhorse for defining and validating the digital data that keeps modern businesses running.

License: Academic Free License version 3.0

Tags: Schema, Validation

Properties: schema, title, description, type, properties, required, additionalProperties, minimum, maximum, exclusiveMinimum, exclusiveMaximum, default, enum, pattern, items, allOf, anyOf, oneOf, not, examples, and $ref

Website: https://json-schema.org

8.19 - Protocol Buffers

Protocol Buffers (protobuf) are Google’s language-neutral, platform-neutral way to define structured data and serialize it efficiently (small, fast). You write a schema in a .proto file, generate code for your language (Go, Java, Python, JS, etc.), and use the generated classes to read/write binary messages.

Fast binary serialized structured data.

Protocol Buffers (protobuf) are Google’s language-neutral, platform-neutral way to define structured data and serialize it efficiently (small, fast). You write a schema in a .proto file, generate code for your language (Go, Java, Python, JS, etc.), and use the generated classes to read/write binary messages.

Protocol Buffers began inside Google in the early 2000s as an internal, compact, schema-driven serialization format; in 2008 Google open-sourced it as proto2. Most recently in 2023, Google introduced “Protobuf Editions” to evolve semantics without fragmenting the language into proto2 vs. proto3, while the project continues to refine tooling, compatibility guidance, and release processes across a broad open-source community.

Owner: Google

License: BSD-3-Clause License

Tags: Schema, Data, Binary, Serialization

Properties: messages, types, fields, cardinality, comments, reserved values, scalars, defaults, enumerations, nested types, vinary, unknown fields, oneOf, maps, packages, and services

Website: https://protobuf.dev/

8.20 - Schema.org

Schema.org is a collaborative, community-driven vocabulary (launched in 2011 by Google, Microsoft, Yahoo!, and Yandex) that defines shared types and properties to describe things on the web—people, places, products, events, and more—so search engines and other consumers can understand page content.

Community-driven schema vocabulary for people, places, and things.

Schema.org is a collaborative, community-driven vocabulary that defines shared types and properties to describe things on the web—people, places, products, events, and more—so search engines and other consumers can understand page content. Publishers annotate pages using formats like JSON-LD (now the common choice), Microdata, or RDFa to express this structured data, which enables features such as rich results, knowledge panels, and better content discovery. The project maintains core and extension vocabularies, evolves through open proposals and discussion, and focuses on practical, interoperable semantics rather than being tied to a single standard body.

License: Creative Commons Attribution-ShareAlike License (CC BY-SA 3.0)

Tags: Schema

Properties: Thing, Action, AchieveAction, LoseAction, TieAction, WinAction, AssessAction, ChooseAction, VoteAction, IgnoreAction, ReactAction, AgreeAction, DisagreeAction, DislikeAction, EndorseAction, LikeAction, WantAction, ReviewAction, ConsumeAction, DrinkAction, EatAction, InstallAction, ListenAction, PlayGameAction, ReadAction, UseAction, WearAction, ViewAction, WatchAction, ControlAction, ActivateAction, AuthenticateAction, DeactivateAction, LoginAction, ResetPasswordAction, ResumeAction, SuspendAction, CreateAction, CookAction, DrawAction, FilmAction, PaintAction, PhotographAction, WriteAction, FindAction, CheckAction, DiscoverAction, TrackAction, InteractAction, BefriendAction, CommunicateAction, AskAction, CheckInAction, CheckOutAction, CommentAction, InformAction, ConfirmAction, RsvpAction, InviteAction, ReplyAction, ShareAction, FollowAction, JoinAction, LeaveAction, MarryAction, RegisterAction, SubscribeAction, UnRegisterAction, MoveAction, ArriveAction, DepartAction, TravelAction, OrganizeAction, AllocateAction, AcceptAction, AssignAction, AuthorizeAction, RejectAction, ApplyAction, BookmarkAction, PlanAction, CancelAction, ReserveAction, ScheduleAction, PlayAction, ExerciseAction, PerformAction, SearchAction, SeekToAction, SolveMathAction, TradeAction, BuyAction, OrderAction, PayAction, PreOrderAction, QuoteAction, RentAction, SellAction, TipAction, TransferAction, BorrowAction, DonateAction, DownloadAction, GiveAction, LendAction, MoneyTransfer, ReceiveAction, ReturnAction, SendAction, TakeAction, UpdateAction, AddAction, InsertAction, AppendAction, PrependAction, DeleteAction, ReplaceAction

Website: https://schema.org/g/latest/

8.21 - JSON-LD

JSON-LD (JavaScript Object Notation for Linking Data) is a W3C standard for expressing linked data in JSON. It adds lightweight semantics to ordinary JSON so machines can understand what the data means, not just its shape—by mapping keys to globally unique identifiers (IRIs) via a @context. Common features include @id (identity), @type (class), and optional graph constructs (@graph).

Introducing semantics into JSON so machines can understand meaning.

JSON-LD (JavaScript Object Notation for Linking Data) is a W3C standard for expressing linked data in JSON. It adds lightweight semantics to ordinary JSON so machines can understand what the data means, not just its shape—by mapping keys to globally unique identifiers (IRIs) via a @context. Common features include @id (identity), @type (class), and optional graph constructs (@graph).

Properties: base, containers, context, direction, graph, imports, included, language, lists, nests, prefixesm propagate, protected, reverse, set, types, values, versions, and vocabulary

Website: https://json-ld.org/

8.22 - Spectral

Spectral is an open-source API linter for enforcing style guides and best practices across JSON Schema, OpenAPI, and AsyncAPI documents. It helps teams ensure consistency, quality, and adherence to organizational standards in API design and development.

Enforcing style guides across JSON artifacts to govern schema.

Spectral is an open-source API linter for enforcing style guides and best practices across JSON Schema, OpenAPI, and AsyncAPI documents. It helps teams ensure consistency, quality, and adherence to organizational standards in API design and development.

While Spectral is a tool, its rules format is increasingly treated as a de facto standard. Spectral traces its roots to Speccy, an API linting engine created by Phil Sturgeon at WeWork. Phil later brought the concept to Stoplight, where Spectral and the next iteration of the rules format were developed; Stoplight was subsequently acquired by SmartBear.

With Spectral, you define rules and rulesets using properties such as given, then, description, message, severity, formats, recommended, and resolved. These can be applied to any JSON or YAML artifact, with primary adoption to date around OpenAPI and AsyncAPI.

The project’s GitHub repository hosts active issues and discussions, largely focused on the CLI. Development continues under SmartBear, including expanding how rules are applied across API operations and support for Arazzo workflow use cases.

Most commonly, Spectral is used to lint and govern OpenAPI and AsyncAPI specifications during design and development. It is expanding into Arazzo workflows and can be applied to any standardized JSON or YAML artifact validated with JSON Schema—making it a flexible foundation for governance across the API lifecycle.

License: Apache

Tags: Rules, Governance

Properties: rules, rulesets, given, then, description, message, severity, formats, recommended, and resolved properties

GitHub: https://github.com/stoplightio/spectral

Standards: JSON Schema

8.23 - Vacuum

RuleSets are how to configure vacuum to know which rules to run for each specification, and how it should evaluate those rules, and a RuleSet is a style guide with each rule being an individual requirement as a part of the overall guide.

Enforcing style guides across JSON artifacts to govern schema.

VACUUM rules in the context of API linting are configuration definitions that specify quality and style requirements for OpenAPI specifications. RuleSets serve as comprehensive style guides where each individual rule represents a specific requirement that the API specification must meet. These rules are configured using YAML or JSON and follow the Spectral Ruleset model, making them fully compatible with Spectral rulesets while adding vacuum-specific enhancements like an id property for backward compatibility and flexible naming. A RuleSet contains a collection of rules that define what to check, where to check it, and how violations should be handled, allowing organizations to enforce consistent API design standards across their specifications.

Each rule within a RuleSet consists of several key components: a given property that uses JSONPath expressions (supporting both RFC 9535 and JSON Path Plus) to target specific sections of the OpenAPI document, a severity level (such as error, warning, or info) that indicates the importance of the rule, and a then clause that specifies which built-in function to apply and what field to evaluate. For example, a rule might target all tag objects in an API specification using $.tags[*] as the JSONPath expression, then apply the truthy function to verify that each tag has a description field populated. Built-in core functions like casing, truthy, and pattern provide the logic for evaluating whether specifications comply with the defined rules, enabling automated validation of API documentation quality, consistency, and adherence to organizational or industry standards.

Vacuum is a soft fork of Spectral, keeping the base format for interoperability, while also taking the specification into a new direction to support OpenAPI Doctor and Vacuum linting rules functionality in tooling and pipelines.

License: Apache

Tags: Rules, Governance

Properties: rules, rulesets, given, then, description, message, severity, formats, recommended, and resolved properties

GitHub: https://quobix.com/vacuum/rulesets/understanding/

Standards: JSON Schema, Spectral

8.24 - Open Policy Agent (OPA)

OPA (Open Policy Agent) is a general-purpose policy engine that unifies policy enforcement across your stack—improving developer velocity, security, and auditability. It provides a high-level, declarative language (Rego) for expressing policies across a wide range of use cases.

Unifies policy enforcement for authentication, security, and auditability.

OPA (Open Policy Agent) is a general-purpose policy engine that unifies policy enforcement across your stack—improving developer velocity, security, and auditability. It provides a high-level, declarative language (Rego) for expressing policies across a wide range of use cases.

Originally developed at Styra in 2016, OPA was donated to the Cloud Native Computing Foundation (CNCF) in 2018 and graduated in 2021.

Rego includes rules and rulesets, unit tests, functions and built-ins, reserved keywords, conditionals, comprehensions/iterations, lookups, assignment, and comparison/equality operators—giving you a concise, expressive way to author and validate policy.

You can contribute on GitHub, follow updates via the blog and its RSS feed, and join conversations in the community Slack and on the OPA LinkedIn page.

OPA works across platforms and operational layers, standardizing policy for key infrastructure such as Kubernetes, API gateways, Docker, CI/CD, and more. It also helps normalize policy across diverse data and API integration patterns used in application and agent automation.

License: Apache

Tags: Policies, Authentication, Authorization

Properties: rules, language, tests, functions, reserved names, grammar, conditionals, iterations, lookups, assignment, equality

Website: https://www.openpolicyagent.org/

8.25 - CSV

CSV (Comma-Separated Values) is a simple text format for storing tabular data where each line represents a row and values within rows are separated by commas (or other delimiters).

Lighter weight data serialization format for data exchange.

CSV (Comma-Separated Values) is a simple, plain-text file format used to store tabular data in a structured way where each line represents a row and values within each row are separated by commas (or other delimiters like semicolons, tabs, or pipes). This straightforward format makes CSV one of the most universally supported data exchange formats, readable by spreadsheet applications like Microsoft Excel, Google Sheets, and LibreOffice Calc, as well as databases, data analysis tools, and virtually every programming language. CSV files are human-readable when opened in a text editor, showing data in a grid-like structure that closely mirrors how it would appear in a spreadsheet. The format’s simplicity—requiring no special markup, tags, or complex syntax—makes it ideal for representing datasets, lists, reports, and any tabular information where relationships between columns and rows need to be preserved.

Despite its simplicity, CSV has become essential for data import/export operations, data migration between systems, bulk data loading into databases, and sharing datasets for data analysis and machine learning. The format is particularly valuable in business contexts for handling customer lists, financial records, inventory data, sales reports, and scientific datasets. CSV files are compact and efficient, requiring minimal storage space compared to more verbose formats like XML or JSON, which makes them ideal for transferring large datasets over networks or storing historical data archives. However, CSV has limitations: it lacks standardized support for data types (everything is typically treated as text unless parsed), has no built-in schema definition, struggles with representing hierarchical or nested data, and can encounter issues with special characters, line breaks within fields, or commas in data values (typically addressed by enclosing fields in quotes). Despite these constraints, CSV remains the go-to format for flat, rectangular data exchange due to its universal compatibility, ease of use, and the fact that it can be created and edited with the most basic tools, from text editors to sophisticated data processing frameworks.

Tags: Data Format

Properties: Text-Based, Plain Text Format, Tabular Data, Row-Based Structure, Column-Based Structure, Delimiter-Separated, Comma Delimiter, Alternative Delimiters, Tab-Separated Values, Pipe-Separated, Semicolon-Separated, Human-Readable, Machine-Parsable, Flat File Format, Simple Syntax, Minimal Markup, No Tags, No Attributes, Lightweight, Compact, Small File Size, Efficient Storage, Fast Parsing, Universal Support, Cross-Platform, Language-Agnostic, Spreadsheet Compatible, Excel Compatible, Google Sheets Compatible, LibreOffice Compatible, Database Import/Export, SQL Bulk Loading, Data Exchange Format, Data Migration, Line-Based Records, Newline Row Separator, Field Delimiter, Quote Encapsulation, Double-Quote Escaping, Escape Characters, Header Row Support, Column Names, Schema-Less, No Data Types, Text-Only Values, No Type Enforcement, No Metadata, No Validation, No Comments, No Processing Instructions, RFC 4180, MIME Type text/csv, File Extension .csv, UTF-8 Encoding, ASCII Compatible, Character Encoding Support, Special Character Handling, Embedded Commas, Embedded Quotes, Embedded Newlines, Field Quoting, Optional Quoting, Whitespace Handling, Trailing Spaces, Leading Spaces, Empty Fields, Null Values, Missing Data Support, Sparse Data, Dense Data, Rectangular Grid, Fixed Columns, Variable Rows, No Nesting, No Hierarchy, No Relationships, Flat Structure, Single Table, No Joins, No Foreign Keys, Streaming Compatible, Incremental Processing, Line-by-Line Reading, Memory Efficient, Large File Support, Append-Only, Chronological Data, Time Series Data, Log Files, Sequential Access, Random Access, Indexing Support, Sorting Compatible, Filtering Compatible, Aggregation Compatible, Data Analysis, Statistical Analysis, Machine Learning Datasets, Training Data, Feature Vectors, Pandas Compatible, R Compatible, Python CSV Module, Java CSV Libraries, .NET CSV Support, Excel Formula Support, Cell Formatting Loss, No Styling, No Colors, No Fonts, No Borders, No Images, No Charts, Data-Only Format, Export Format, Import Format, Batch Processing, ETL Operations, Data Warehousing, Business Intelligence, Reporting Format, Audit Trails, Transaction Logs, Customer Lists, Contact Lists, Inventory Data, Sales Data, Financial Records, Scientific Data, Sensor Data, Measurement Data, Survey Results, Poll Data, Census Data, Demographic Data, Geographic Data, Coordinate Data, Latitude Longitude, Address Lists, Email Lists, Product Catalogs, Price Lists, Stock Data, Market Data, Historical Data, Archive Format, Backup Format, Version Control Friendly, Diff-Friendly, Merge-Friendly, Git Compatible, Text Editor Compatible, Command Line Tools, Awk Processing, Sed Processing, Grep Searching, Cut Command, Unix Tools, Shell Scripting, Automation Friendly, Cron Job Compatible, Scheduled Exports, API Responses, Web Scraping Output, Data Dumps, Bulk Downloads, FTP Transfer, Email Attachments, Cloud Storage, S3 Compatible, Azure Blob Storage, Google Cloud Storage, Database Export, MySQL Export, PostgreSQL Export, SQLite Export, Oracle Export, SQL Server Export, MongoDB Export, NoSQL Export, Data Conversion, Format Transformation, JSON to CSV, XML to CSV, Excel to CSV, CSV to JSON, Interoperability, Legacy System Support, Backwards Compatible, Universal Standard, Industry Standard, De Facto Standard, Widely Adopted, Mature Format, Production Ready, Battle Tested, Simple Implementation, Easy Generation, Easy Parsing, Minimal Dependencies, No External Libraries Required, Low Overhead, High Performance, Scalable, Concatenation Support, Split Support, Chunking Support, Partitioning Support, Compression Compatible, Gzip Compatible, Zip Compatible, Tar Compatible

Wikipedia: https://en.wikipedia.org/wiki/Comma-separated_values

8.26 - HTML

HTML (HyperText Markup Language) is the standard markup language used to create and structure content on web pages, defining elements like headings, paragraphs, links, images, and forms through a system of tags that web browsers interpret and render as visual displays.

The standard markup language powering the Web.

HTML (HyperText Markup Language) is the foundational markup language of the World Wide Web, created by Tim Berners-Lee in 1991, that defines the structure and content of web pages through a system of elements enclosed in angle-bracket tags. HTML provides the semantic framework for organizing information on the web, using tags like

for headings,
for paragraphs, for hyperlinks, for images,
for tabular data, and
for user input. These elements create a hierarchical document structure called the Document Object Model (DOM) that web browsers parse and render into the visual pages users see and interact with. HTML is a declarative language, meaning developers describe what content should appear and how it should be structured rather than specifying how to display it—the actual visual presentation is handled by CSS (Cascading Style Sheets), while interactive behavior is managed by JavaScript. This separation of concerns allows HTML to focus purely on semantic meaning and content structure, making web pages accessible to screen readers, search engines, and various devices.
Modern HTML (currently HTML5, standardized by the W3C and WHATWG) has evolved far beyond simple text formatting to support rich multimedia content, complex web applications, and interactive experiences without requiring plugins. HTML5 introduced semantic elements like
,
,
,
, and
that provide meaningful structure for both developers and assistive technologies, improving accessibility and SEO. The language now includes native support for audio and video playback through
Wikipedia: https://en.wikipedia.org/wiki/HTML
8.27 - Java Database Connectivity (JDBC)
JDBC (Java Database Connectivity) is a Java API that provides a standard interface for Java applications to connect to and interact with relational databases, allowing developers to execute SQL queries, retrieve results, and manage database transactions in a database-agnostic way.
Lighter weight data serialization format for data exchange.
JDBC (Java Database Connectivity) is a Java API specification developed by Sun Microsystems (now Oracle) that provides a standard, database-independent interface for Java applications to interact with relational databases. Released as part of the Java platform, JDBC abstracts the complexities of database communication by defining a consistent set of interfaces and classes that allow developers to connect to databases, execute SQL statements, retrieve and process query results, and manage transactions without worrying about the underlying database vendor’s specific implementation details. JDBC works through database-specific drivers that implement the JDBC interfaces—these drivers translate the standard JDBC calls into the native protocol of the particular database system (such as Oracle, MySQL, PostgreSQL, SQL Server, or DB2). This driver-based architecture enables developers to write portable database code that can switch between different database systems by simply changing the JDBC driver and connection string, rather than rewriting the entire data access layer.
JDBC provides several core components that work together to facilitate database operations: the DriverManager class for establishing connections, Connection objects that represent active database sessions, Statement and PreparedStatement objects for executing SQL queries and updates, ResultSet objects for iterating through query results, and various metadata classes for discovering database and result set structure at runtime. The API supports both simple statement execution and more advanced features like prepared statements with parameter binding (which prevent SQL injection attacks and improve performance through query plan caching), callable statements for executing stored procedures, batch processing for efficient bulk operations, transaction management with commit and rollback capabilities, and connection pooling for optimal resource utilization in multi-threaded applications. JDBC has become the foundation for higher-level data access frameworks like Hibernate, JPA (Java Persistence API), Spring JDBC, MyBatis, and jOOQ, which build upon JDBC’s low-level capabilities to provide object-relational mapping, declarative transaction management, and more developer-friendly abstractions. Despite the emergence of these frameworks, JDBC remains essential knowledge for Java developers and continues to be used directly in performance-critical scenarios, legacy systems, and situations requiring fine-grained control over database interactions.
Tags: Databases, Connectors
Properties:
Wikipedia: https://en.wikipedia.org/wiki/Java_Database_Connectivity
8.28 - JSON
JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format that uses human-readable syntax with key-value pairs, arrays, and primitive data types (strings, numbers, booleans, null) to represent structured data.
Lighter weight data serialization format for data exchange.
JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format that has become the de facto standard for data exchange on the web and between applications. Originally derived from JavaScript object literal syntax, JSON uses a simple, human-readable structure consisting of key-value pairs (objects), ordered lists (arrays), and primitive data types including strings, numbers, booleans, and null. Its straightforward syntax makes it easy for both humans to read and write and for machines to parse and generate, which has contributed to its widespread adoption across virtually all programming languages and platforms. JSON’s simplicity—using only curly braces for objects, square brackets for arrays, and colons to separate keys from values—makes it accessible to developers while remaining efficient enough for production use in everything from REST APIs to configuration files.
Beyond its use in web APIs and AJAX communications, JSON has become the preferred format for configuration files, data storage in NoSQL databases like MongoDB and CouchDB, and data serialization in modern applications. Unlike XML, JSON has minimal overhead with no opening and closing tags, making payloads smaller and faster to transmit over networks. JSON’s language-agnostic nature means that nearly every programming language has robust libraries for parsing and generating JSON, enabling seamless interoperability between systems written in different languages. While JSON lacks some features found in other formats—such as comments (though JSON5 and JSONC variants address this), schema validation (addressed by JSON Schema), and support for binary data (typically handled through Base64 encoding)—its balance of simplicity, readability, and universal support has made it the most popular data interchange format in modern software development, particularly in microservices architectures, cloud services, and mobile applications.
Tags: Data Format
Properties: Text-Based, Lightweight, Human-Readable, Machine-Parsable, Language-Agnostic, Platform-Independent, Data Interchange Format, Key-Value Pairs, Nested Structures, Object Support, Array Support, Primitive Data Types, String Support, Number Support, Boolean Support, Null Support, Unicode Support, UTF-8 Encoding, Hierarchical Structure, Tree Structure, Self-Describing, Schema-Less, Curly Brace Syntax, Square Bracket Syntax, Colon Separator, Comma Delimiter, Quote-Delimited Strings, No Comments, Whitespace Insensitive, Compact Format, Minimal Overhead, Fast Parsing, Efficient Transmission, Small Payload Size, Web-Native, JavaScript-Compatible, REST API Standard, AJAX Communication, Universal Library Support, Cross-Language Compatibility, Serialization Format, Deserialization Support, Type Safety, Strongly Typed Values, Unambiguous Syntax, Simple Grammar, Easy to Learn, Easy to Generate, Easy to Parse, Standards-Based, RFC 8259, ECMA-404, ISO/IEC 21778, No Processing Instructions, No Attributes, No Namespaces, No Mixed Content, Strict Syntax Rules, Case Sensitive, Double-Quote Strings, Escape Sequences, Backslash Escaping, Unicode Escaping, Number Precision, Integer Support, Floating Point Support, Scientific Notation, Negative Numbers, No Leading Zeros, No Trailing Commas, No Undefined Values, No Functions, No Dates, No Binary Data, No Comments Support, No Metadata, No Schema Enforcement, Dynamic Typing, Flexible Structure, Recursive Nesting, Arbitrary Depth, Object Ordering Unspecified, Duplicate Keys Discouraged, Array Ordering Preserved, Immutable Once Generated, Stateless, Context-Free, Validation Support via JSON Schema, Extension Support via JSON-LD, JSON5 Variants, JSONC Variants, Pretty Printing, Minification Support, Compression Compatible, Streaming Support, Incremental Parsing, Event-Driven Parsing, DOM Parsing, SAX-Style Parsing, JSONPath Query Support, JMESPath Support, JSON Pointer Support, JSON Patch Support, JSON Merge Patch, API Documentation, Swagger/OpenAPI Support, Configuration Files, NoSQL Database Format, MongoDB Support, CouchDB Support, Document Store Format, Key-Value Store, Cache Storage, Session Storage, Local Storage, Message Queue Format, Event Sourcing, Log Format, Structured Logging, Telemetry Data, Metrics Format, Error Reporting, Response Format, Request Format, Webhook Payloads, OAuth Tokens, JWT Format, Cookie Data, Form Data Alternative, GraphQL Responses, RPC Format, Service Communication, Microservices Protocol, Cloud Service Standard, Mobile App Data, IoT Data Format, Real-Time Communication, WebSocket Messages, Server-Sent Events, Push Notifications, Content Negotiation, MIME Type application/json, File Extension .json, Backwards Compatible, Forward Compatible, Interoperable, Widely Adopted, Industry Standard, Best Practice Format, Production Ready, Battle Tested, Mature Ecosystem, Tool Support, IDE Integration, Syntax Highlighting, Linting Support, Formatting Tools, Conversion Tools, Diff Tools, Merge Tools, Comparison Tools, Testing Support, Mock Data Generation, Faker Integration, Schema Generation, Type Generation, Code Generation, Documentation Generation
Website: https://www.json.org/json-en.html
8.29 - Markdown
Markdown is a lightweight markup language that uses plain text formatting syntax (such as asterisks for emphasis, hashes for headings, and brackets for links) to create formatted documents that are easy to read in raw form and can be converted to HTML and other formats.
Simple and lighter weight markup language for plain text formatting.
Markdown is a lightweight markup language created by John Gruber in 2004 that allows writers to format text using simple, intuitive plain-text syntax that remains highly readable even in its raw, unformatted state. Unlike HTML or other markup languages that use verbose tags and angle brackets, Markdown uses natural symbols and conventions—asterisks or underscores for emphasis, hashes for headings, dashes or asterisks for lists, and square brackets with parentheses for links. This human-friendly approach makes it possible to write formatted documents in any text editor without needing specialized software, while the resulting text remains clean and easy to read whether it’s being edited, displayed raw, or converted to HTML. Markdown’s philosophy centers on readability and simplicity: the formatting syntax is designed to look like what it means, so bold text visually suggests bold formatting, and # Heading clearly indicates a heading level.
Beyond simple text formatting, Markdown has become the standard format for documentation, README files, technical writing, blogging platforms, note-taking applications, and collaborative writing tools. Platforms like GitHub, Stack Overflow, Reddit, Discord, and Slack have adopted Markdown (or Markdown-inspired syntax) for user-generated content, making it essential knowledge for developers and technical writers. Markdown files can be easily converted to HTML, PDF, Word documents, presentations, and other formats using tools like Pandoc, while static site generators like Jekyll, Hugo, and MkDocs build entire websites from Markdown source files. Various flavors and extensions of Markdown have emerged—including GitHub Flavored Markdown (GFM), CommonMark, and MultiMarkdown—that add features like tables, task lists, footnotes, syntax highlighting for code blocks, and strikethrough text. This extensibility, combined with Markdown’s simplicity and the fact that it’s plain text (making it version-control friendly, searchable, and future-proof), has made it the de facto standard for technical documentation and web content creation in the modern software development ecosystem.
Tags: Text, Formatting
Properties: Lightweight Markup Language, Plain Text Format, Human-Readable, Easy to Write, Easy to Read, Simple Syntax, Intuitive Formatting, Text Editor Compatible, No Special Software Required, Readability-Focused, Natural Symbols, Minimal Markup, Clean Appearance, Raw Text Readable, HTML Convertible, Format Agnostic, Multi-Format Export, Pandoc Compatible, Static Site Generation, Documentation Standard, README Files, Technical Writing, Blogging Platform Support, Note-Taking Format, Collaborative Writing, Version Control Friendly, Git Compatible, Diff-Friendly, Merge-Friendly, Searchable, Grep Compatible, Future-Proof, Platform-Independent, Cross-Platform, Language-Agnostic, File Extension .md, File Extension .markdown, MIME Type text/markdown, UTF-8 Encoding, ASCII Compatible, Heading Syntax, Hash Headings, Multiple Heading Levels, Emphasis Support, Bold Text, Italic Text, Strikethrough, Asterisk Formatting, Underscore Formatting, List Support, Ordered Lists, Unordered Lists, Nested Lists, Bullet Points, Numbered Items, Link Syntax, Inline Links, Reference Links, URL Auto-Detection, Image Embedding, Alt Text Support, Code Formatting, Inline Code, Code Blocks, Fenced Code Blocks, Syntax Highlighting, Language Specification, Backtick Syntax, Triple Backticks, Blockquotes, Nested Blockquotes, Horizontal Rules, Line Breaks, Paragraph Separation, Whitespace Handling, Escape Characters, Backslash Escaping, Special Character Support, HTML Embedding, Raw HTML Support, Inline HTML, Block-Level HTML, Table Support, Pipe Tables, Grid Tables, Task Lists, Checkbox Support, Footnotes, Definition Lists, Abbreviations, Superscript, Subscript, Emoji Support, Auto-Linking, Email Links, Reference-Style Links, Image References, Anchor Links, ID Attributes, Class Attributes, Metadata Support, Front Matter, YAML Headers, Title Blocks, Author Information, Date Stamps, GitHub Flavored Markdown, CommonMark Specification, MultiMarkdown, Markdown Extra, R Markdown, Pandoc Markdown, Kramdown, Redcarpet, Showdown, Marked, Remarkable, Markdown-it, Parser Libraries, Renderer Support, Preview Tools, Live Preview, Split View Editing, WYSIWYG Editors, Syntax Highlighting Editors, VS Code Support, Atom Support, Sublime Text Support, Vim Support, Emacs Support, Web Editors, Browser-Based, Dillinger, StackEdit, HackMD, Typora, Obsidian, Notion Support, Bear Notes, Joplin, Simplenote, GitHub Support, GitLab Support, Bitbucket Support, Stack Overflow Support, Reddit Support, Discord Support, Slack Support, Jupyter Notebooks, R Studio, Documentation Generators, MkDocs, Docusaurus, VuePress, GitBook, Read the Docs, Sphinx Markdown, Jekyll Support, Hugo Support, Gatsby Support, Hexo Support, Blog Platforms, WordPress Markdown, Medium Support, Dev.to, Hashnode, Ghost CMS, Static Sites, Portfolio Sites, Personal Websites, Project Documentation, API Documentation, User Manuals, Tutorials, Guides, Books, Academic Papers, Presentations, Slideshows, Reveal.js, Remark, PDF Generation, LaTeX Support, Math Equations, MathJax, KaTeX, Diagrams, Mermaid Support, PlantUML, Graphviz, Flowcharts, Sequence Diagrams, Charts, Graphs, Academic Citations, Bibliography Support, BibTeX, Citation Keys, Cross-References, Table of Contents, Auto-Generated TOC, Navigation, Internal Links, Section Links, Keyboard Shortcuts, Productivity Tools, Writing Focus, Distraction-Free, Minimal Interface, Template Support, Boilerplate, Snippets, Macros, Variables, Include Files, Transclusion, Plugin System, Extensions, Custom Renderers, Hooks, Filters, Preprocessing, Postprocessing, Linting, Validation, Style Guides, Best Practices, Accessibility, Screen Reader Friendly, Semantic HTML Output, Mobile Friendly, Responsive, Print Stylesheets, Export Options, Word Export, DOCX Conversion, ePub Generation, Mobi Format, Slide Decks, HTML Slides, PDF Slides, PowerPoint Export, Open Source, Free Software, Community-Driven, Wide Adoption, Industry Standard, Developer Documentation, Software README, Change Logs, Release Notes, Contributing Guidelines, Code of Conduct, License Files, Issue Templates, Pull Request Templates, Wiki Pages, Knowledge Bases, Internal Documentation, Team Collaboration, Remote Work, Asynchronous Communication, Changelog Generation, Version Documentation, Migration Guides, Onboarding Docs, Training Materials, Educational Content, Course Materials, Learning Resources, Cheat Sheets, Quick References
Wikipedia: https://en.wikipedia.org/wiki/Markdown
8.30 - ODBC
ODBC (Open Database Connectivity) is a standard API specification that provides a database-agnostic interface for applications to connect to and interact with various relational database management systems through database-specific drivers, enabling cross-platform database access without requiring application code changes.
Lighter weight data serialization format for data exchange.
ODBC (Open Database Connectivity) is a standard application programming interface developed by Microsoft in the early 1990s that provides a universal method for applications to access different database management systems through a consistent set of function calls. ODBC acts as a middleware layer that sits between applications and databases, abstracting the complexities of different database protocols and SQL dialects behind a standardized interface. Applications use ODBC function calls to connect to databases, execute SQL statements, retrieve results, and manage transactions, while database-specific ODBC drivers translate these standard calls into the native commands understood by each particular database system (such as Oracle, SQL Server, MySQL, PostgreSQL, DB2, or Access). This architecture enables developers to write database code once and deploy it across multiple database platforms by simply changing the ODBC driver and connection string, rather than rewriting data access logic for each database vendor. ODBC supports both Windows and Unix-like systems (through projects like unixODBC and iODBC), making it a truly cross-platform solution for database connectivity.
ODBC provides a comprehensive set of capabilities including connection management through the ODBC Driver Manager, statement execution via handles that represent database connections and SQL statements, result set processing with cursors for navigating query results, transaction control with commit and rollback operations, and metadata discovery to query database structure and capabilities at runtime. The API supports prepared statements with parameter binding for improved performance and SQL injection prevention, batch operations for efficient bulk processing, and stored procedure execution. ODBC has become the foundation for database connectivity in many programming languages and frameworks—it’s used directly in C/C++ applications, accessed through wrappers in languages like Python (pyodbc), PHP (ODBC extension), Ruby, and Perl, and serves as the underlying technology for higher-level data access frameworks like ADO.NET, OLE DB, and various ORM tools. While JDBC provides similar functionality for Java applications, ODBC remains the dominant standard for database connectivity in Windows environments, business intelligence tools (like Tableau, Power BI, and Crystal Reports), reporting systems, ETL tools, and legacy applications. Despite the emergence of native database drivers and modern database APIs, ODBC continues to be widely used in enterprise environments due to its maturity, broad database support, standardization, and the extensive ecosystem of tools and applications built around it.
Tags: Databases, Connectors
Properties: Open Database Connectivity, Standard API, Microsoft-Developed, Database-Agnostic, Middleware Layer, Abstraction Layer, Driver-Based Architecture, Database Independence, Platform-Independent, Cross-Platform, Windows Support, Unix Support, Linux Support, unixODBC, iODBC, Driver Manager, Connection Pooling, Database Drivers, Vendor-Specific Drivers, Third-Party Drivers, SQL Execution, Query Processing, Result Set Handling, Transaction Management, Commit Support, Rollback Support, Savepoint Support, Connection Management, Connection Strings, DSN Support, Data Source Names, System DSN, User DSN, File DSN, DSN-Less Connections, Handle-Based API, Environment Handles, Connection Handles, Statement Handles, Descriptor Handles, Function Calls, C Language API, Procedural Interface, ODBC 1.0, ODBC 2.0, ODBC 3.0, ODBC 3.8, ODBC 4.0, Backward Compatible, Forward Compatible, SQL-92 Standard, SQL Compliance, Standard SQL, Extended SQL, Vendor Extensions, Prepared Statements, Parameter Binding, Input Parameters, Output Parameters, Input/Output Parameters, Dynamic SQL, Static SQL, Statement Execution, Direct Execution, Prepared Execution, Batch Processing, Bulk Operations, Array Binding, Row-Wise Binding, Column-Wise Binding, Cursor Support, Forward-Only Cursors, Scrollable Cursors, Static Cursors, Dynamic Cursors, Keyset-Driven Cursors, Cursor Positioning, Fetch Operations, Absolute Positioning, Relative Positioning, Bookmark Support, Result Set Processing, Row Retrieval, Column Access, Data Type Mapping, Type Conversion, NULL Handling, Binary Data, BLOB Support, CLOB Support, Large Object Handling, Metadata Access, Schema Discovery, Catalog Functions, Table Information, Column Information, Index Information, Primary Keys, Foreign Keys, Stored Procedures, Procedure Execution, Callable Statements, Return Values, Output Parameters, Error Handling, Error Codes, SQL States, Diagnostic Records, Warning Messages, Error Messages, Connection Attributes, Statement Attributes, Environment Attributes, Transaction Isolation, Read Uncommitted, Read Committed, Repeatable Read, Serializable, Autocommit Mode, Manual Commit, Distributed Transactions, Two-Phase Commit, XA Protocol, Database Specific Features, Proprietary Extensions, ODBC Escape Sequences, Date/Time Literals, Outer Join Syntax, Scalar Functions, String Functions, Numeric Functions, Date Functions, System Functions, Conversion Functions, Aggregate Functions, Performance Optimization, Query Plan Caching, Statement Caching, Connection Reuse, Lazy Loading, Asynchronous Operations, Non-Blocking Calls, Thread Safety, Multi-Threading Support, Concurrent Access, Connection Sharing, Multiple Active Result Sets, MARS Support, Unicode Support, UTF-8, UTF-16, Wide Character Functions, ANSI Functions, Character Set Conversion, Localization, Internationalization, Security, Authentication, SQL Server Authentication, Windows Authentication, Kerberos, Encrypted Connections, SSL/TLS Support, Certificate Validation, Password Encryption, Credential Management, Trace Logging, Debug Mode, Performance Monitoring, Profiling, Statistics Collection, Diagnostic Tools, ODBC Administrator, ODBC Data Source Administrator, Driver Configuration, Connection Testing, Trace File Generation, Enterprise Support, Business Intelligence, Reporting Tools, Tableau Integration, Power BI Integration, Crystal Reports, QlikView, SAP BusinessObjects, ETL Tools, SSIS Integration, Informatica, Talend, Data Migration, Data Warehousing, Data Analytics, OLAP Support, Multidimensional Data, Cubes, Data Modeling, Legacy Application Support, Mainframe Connectivity, AS/400 Access, Database Gateway, Heterogeneous Queries, Linked Servers, Remote Data Access, Distributed Queries, Federation, ADO.NET Integration, OLE DB Bridge, DAO Support, RDO Support, Programming Language Support, C/C++, Python pyodbc, PHP ODBC Extension, Perl DBI, Ruby ODBC, VB.NET, C# .NET, PowerBuilder, Delphi, FileMaker, Access Integration, Excel Integration, Office Applications, Desktop Applications, Web Applications, Client-Server Applications, n-Tier Architecture, Application Servers, Middleware Integration, COM Integration, ActiveX, DCOM, Registry Configuration, INI Files, Configuration Files, Driver Installation, ODBC Installer API, Dynamic Loading, Runtime Binding, Late Binding, API Versioning, Feature Detection, Capability Negotiation, Standards Compliance, ISO/IEC Standard, X/Open Standard, SQL Access Group, Open Group Specification, Vendor Neutral, Multi-Database Support, Oracle Support, SQL Server Support, MySQL Support, PostgreSQL Support, DB2 Support, Sybase Support, Informix Support, Teradata Support, SQLite Support, Access Support, Excel Support, Text File Support, CSV Support, FoxPro Support, dBase Support, ODBC-JDBC Bridge, Database Abstraction, Portability, Code Reusability, Write Once Run Anywhere, Deployment Flexibility, Production Ready, Enterprise Grade, Mission Critical, High Availability, Failover Support, Load Balancing, Clustering Support, Scalability, Resource Management, Memory Management, Handle Management, Timeout Handling, Query Timeout, Connection Timeout, Login Timeout, Retry Logic, Automatic Reconnection, Connection Resilience, Error Recovery, Rollback on Error, Industry Standard, Widely Adopted, Mature Technology, Proven Technology, Battle Tested, Documentation Rich, Training Available, Certification Programs, Community Support, Vendor Support, Long-Term Support, Maintenance Releases, Security Patches, Bug Fixes, Performance Improvements
Website: https://www.json.org/json-en.html
8.31 - YAML
YAML (“YAML Ain’t Markup Language”) is a human-friendly data serialization format used for configuration and data exchange, built around indentation to express structure (mappings/objects, sequences/arrays, and scalars). It supports comments (#), multi-document streams (—), anchors/aliases for reuse (&id, id), and optional type tags.
Human-friendly data serialization format for data exchange.
YAML (“YAML Ain’t Markup Language”) is a human-friendly data serialization format used for configuration and data exchange, built around indentation to express structure (mappings/objects, sequences/arrays, and scalars). It supports comments (#), multi-document streams (—), anchors/aliases for reuse (&id, id), and optional type tags. YAML 1.2 aligns closely with JSON (JSON is a subset of YAML 1.2), but YAML is more concise and readable for humans—hence its popularity in app configs, CI/CD pipelines, Kubernetes manifests, and Docker Compose—while also being sensitive to whitespace and, historically, to schema ambiguities (e.g., 1.1 vs 1.2 boolean parsing).
YAML was introduced in 2001 by Clark Evans (with Oren Ben-Kiki and Ingy döt Net) as a human-friendly data serialization format inspired by scripting languages and intended to be simpler than XML for configs and data exchange. The 1.1 spec (mid-2000s) broadened typing via schemas but also introduced notorious ambiguities (e.g., unquoted strings like “on”/“off” parsing as booleans). YAML 1.2 (2009) realigned the language with JSON—making JSON a subset of YAML—and clarified many edge cases, after which YAML gained wide adoption across developer tooling and ops: Rails configs, Ansible playbooks, Docker Compose files, CI/CD pipelines, and, most visibly, Kubernetes manifests in the 2010s. The spec continues to be maintained under the 1.2 line with incremental clarifications and errata.
License: MIT License
Tags: Data Formats
Properties: Scalars, Comments, Documents, Streams, Anchors, Aliases, Tags, Types
GitHub: https://yaml.org/
8.32 - XML
XML (eXtensible Markup Language) is a text-based, Unicode-friendly format for representing structured data using nested elements (tags) and attributes, making documents both human- and machine-readable. It’s “extensible” because you define your own vocabulary (element and attribute names), organize data hierarchically, and use namespaces to avoid naming collisions.
Text-based unicode-friendly format for representing structured data.
XML (eXtensible Markup Language) is a text-based, Unicode-friendly format for representing structured data using nested elements (tags) and attributes, making documents both human- and machine-readable. It’s “extensible” because you define your own vocabulary (element and attribute names), organize data hierarchically, and use namespaces to avoid naming collisions. XML supports validation with DTDs or XML Schema (XSD), and a rich toolset—XPath for querying, XSLT for transformation, DOM/SAX for parsing—though it’s more verbose than alternatives like JSON. Common uses include configuration files, document publishing, and system-to-system data exchange.
XML grew out of SGML (ISO 8879:1986) in the mid-1990s as a simpler, web-friendly subset led at the W3C by Jon Bosak and others; the XML 1.0 spec became a W3C Recommendation in February 1998 (with a minor 1.1 revision in 2004). Around it, a family of standards emerged—Namespaces (1999), XPath and XSLT 1.0 (1999), DOM levels (late 1990s–2000s), XML Schema 1.0 (2001), and related formats like SVG (2001), SOAP (2000/2003), RSS/Atom (early 2000s), and office document formats (ODF, OOXML). XML powered early web services, configuration, publishing, and data interchange across enterprises; while JSON later became dominant for browser-centric APIs, XML remains entrenched in many protocols, document workflows, and enterprise systems.
License: W3C Document License
Tags: Data Formats
Properties: Namespaces, Infosets, Tree Models, Character Data Forms, Instructions, Links, Declarations
GitHub: https://www.w3.org/TR/xml/
8.33 - OAuth 2.0
OAuth 2.0 is an industry-standard protocol that enables secure, delegated access to APIs without requiring users to share their passwords with applications. Instead of handing over credentials, a user authorizes a trusted identity provider—such as Google, Microsoft, or an enterprise login system—to issue short-lived access tokens to a client application.
Allow users to grant access to their applications.
OAuth 2.0 is an industry-standard authorization framework that enables applications to obtain limited access to user accounts on third-party services without exposing user passwords. Developed by the Internet Engineering Task Force (IETF) and published as RFC 6749 in 2012, OAuth 2.0 solves the fundamental problem of secure delegated access—allowing users to grant applications permission to access their data on other services (like Google, Facebook, GitHub, or Microsoft) without sharing their login credentials. Instead of giving an application your password, OAuth 2.0 uses access tokens: temporary, limited-scope credentials that specify exactly what data the application can access and for how long. This token-based approach is what powers the “Sign in with Google” or “Connect with GitHub” buttons seen across the web, enabling seamless single sign-on (SSO) experiences while maintaining security. The framework defines four primary authorization flows (or “grant types”): Authorization Code Grant for server-side web applications, Implicit Grant (now deprecated) for browser-based apps, Client Credentials Grant for machine-to-machine communication, and Resource Owner Password Credentials Grant for trusted applications, each tailored to different security requirements and use cases.
OAuth 2.0 operates through a carefully orchestrated dance between four parties: the Resource Owner (the user), the Client (the application requesting access), the Authorization Server (which authenticates the user and issues tokens), and the Resource Server (which hosts the protected data). When a user wants to connect an application to their account on another service, they’re redirected to the authorization server where they authenticate and explicitly consent to the permissions being requested. Upon approval, the authorization server issues an authorization code (in the most secure flow) which the client application exchanges for an access token and optionally a refresh token. The access token—typically a JSON Web Token (JWT) or opaque string—is then included in API requests to the resource server to prove authorization. OAuth 2.0 has become the backbone of modern API security and is used by virtually every major platform including Google, Microsoft, Facebook, Twitter, GitHub, Salesforce, and thousands of other services. The framework has evolved with extensions like PKCE (Proof Key for Code Exchange) to secure mobile and single-page applications, token introspection for validating tokens, and token revocation for ending sessions. While OAuth 2.0 handles authorization (what you’re allowed to do), it’s often used alongside OpenID Connect (OIDC), an identity layer built on top of OAuth 2.0 that adds authentication (who you are), together forming the foundation for modern identity and access management in web, mobile, and API ecosystems.
License: Simplified BSD License
Tags: Authentication, Authorization, Security
Properties: Authorization Framework, Industry Standard, IETF Standard, RFC 6749, RFC 6750, Delegated Access, Token-Based Authorization, Access Tokens, Refresh Tokens, Authorization Codes, Grant Types, Authorization Code Grant, Implicit Grant, Client Credentials Grant, Resource Owner Password Credentials Grant, Device Authorization Grant, Four-Party Model, Resource Owner, Client Application, Authorization Server, Resource Server, User Consent, Permission Scopes, Limited Access, Temporary Credentials, No Password Sharing, Credential Separation, Token Expiration, Time-Limited Access, Revocable Access, Single Sign-On, SSO Support, Third-Party Access, API Authorization, Secure Delegation, HTTPS Required, TLS Required, Redirect URIs, Callback URLs, State Parameter, CSRF Protection, Client Authentication, Client ID, Client Secret, Public Clients, Confidential Clients, Token Endpoint, Authorization Endpoint, Redirect Endpoint, Bearer Tokens, Token Types, JWT Support, JSON Web Tokens, Opaque Tokens, Token Introspection, Token Revocation, Scope-Based Permissions, Fine-Grained Access Control, Read-Only Access, Write Access, Admin Access, Custom Scopes, Scope Validation, Consent Screen, User Authorization, Explicit Consent, Permission Grants, OAuth Flows, Web Application Flow, Mobile Application Flow, SPA Flow, Server-to-Server Flow, Machine-to-Machine, M2M Authentication, Service Accounts, PKCE Extension, Proof Key for Code Exchange, Code Verifier, Code Challenge, S256 Method, Plain Method, Mobile Security, Native App Support, Single Page Applications, Browser-Based Apps, Backend Applications, Microservices, API Gateway Integration, Identity Provider, IdP Integration, Social Login, Sign in with Google, Sign in with Facebook, Sign in with GitHub, Sign in with Microsoft, Sign in with Apple, Enterprise SSO, SAML Bridge, LDAP Integration, Active Directory, Azure AD, Okta Support, Auth0 Support, Keycloak Support, AWS Cognito, Google Identity Platform, Multi-Tenant Support, Organization Support, Workspace Integration, OpenID Connect, OIDC Layer, Authentication Extension, ID Tokens, UserInfo Endpoint, Claims, Profile Information, Email Verification, Identity Verification, Multi-Factor Authentication, MFA Support, Step-Up Authentication, Risk-Based Authentication, Adaptive Authentication, Session Management, Logout Support, Back-Channel Logout, Front-Channel Logout, Token Exchange, Token Binding, Token Lifetime, Access Token Expiration, Refresh Token Rotation, Sliding Expiration, Absolute Expiration, Security Best Practices, Threat Mitigation, Authorization Code Injection, Redirect URI Validation, State Validation, Nonce Support, Replay Attack Prevention, Token Leakage Prevention, XSS Protection, CSRF Protection, Clickjacking Prevention, Open Redirect Prevention, Client Registration, Dynamic Client Registration, Client Metadata, Redirect URI Registration, OAuth 2.0 Security BCP, Best Current Practice, RFC 8252, RFC 8628, RFC 7636, RFC 7009, RFC 7662, Standardized Endpoints, Discovery Document, Well-Known Configuration, Metadata Endpoint, JWKS Endpoint, JSON Web Key Sets, Key Rotation, Signature Verification, Token Validation, Audience Validation, Issuer Validation, Expiration Checking, Clock Skew Tolerance, Token Caching, Performance Optimization, Rate Limiting, Throttling, Quota Management, Usage Tracking, Audit Logging, Security Events, Compliance, GDPR Compliance, Privacy Protection, Data Minimization, Consent Management, User Control, Permission Revocation, Third-Party App Management, Connected Apps, Authorized Applications, Trust Management, Vendor Neutral, Platform Agnostic, Language Independent, Cross-Platform, REST API Compatible, GraphQL Compatible, gRPC Support, WebSocket Support, Server-Side Implementation, Client-Side Libraries, SDK Support, Java Libraries, Python Libraries, Node.js Libraries, .NET Libraries, PHP Libraries, Ruby Libraries, Go Libraries, Rust Support, Mobile SDKs, iOS SDK, Android SDK, React Native, Flutter Support, JavaScript Libraries, TypeScript Support, Framework Integration, Spring Security, Express.js, Django, Flask, Laravel, Rails, ASP.NET, Production Ready, Enterprise Grade, Scalable, High Availability, Load Balancing, Distributed Systems, Cloud Native, Container Support, Kubernetes Integration, Service Mesh, API Management, Kong Integration, Apigee Support, AWS API Gateway, Azure API Management, Google Cloud Endpoints, Rate Limit Headers, Token Response Format, Error Responses, Error Codes, Invalid Grant, Unauthorized Client, Access Denied, Unsupported Grant Type, Invalid Scope, Server Error, Temporarily Unavailable, Standard Error Format, JSON Response, URL Encoding, Form Encoding, Content Negotiation, Accept Headers, CORS Support, Cross-Origin Requests, Preflight Requests, Credentials Mode, Same-Site Cookies, Secure Cookies, HttpOnly Cookies, Cookie-Based Sessions, Stateless Authentication, Distributed Sessions, Session Stores, Redis Integration, Database Storage, In-Memory Cache, Token Storage, Secure Storage, Keychain Integration, Encrypted Storage, Client-Side Storage, LocalStorage Considerations, SessionStorage, Mobile Storage, Biometric Authentication, Fingerprint Support, Face ID, Touch ID, Hardware Tokens, YubiKey Support, FIDO2, WebAuthn Integration, Passwordless Authentication, Magic Links, OTP Support, SMS Authentication, Email Authentication, Backup Codes, Recovery Options, Account Linking, Social Account Linking, Multiple Identities, Federation, Identity Federation, Cross-Domain SSO, Enterprise Federation, B2B Integration, B2C Support, Customer Identity, CIAM Platform, User Management, Profile Management, Attribute Mapping, Claim Transformation, Custom Claims, Role-Based Access, RBAC Support, Attribute-Based Access, ABAC Support, Policy Enforcement, Fine-Grained Authorization, Resource-Level Permissions, Action-Level Permissions, Context-Aware Access, Location-Based Access, Device-Based Access, Time-Based Access, IP Restrictions, Geofencing, Conditional Access, Step-Up Authorization, Elevated Privileges, Temporary Access, Just-In-Time Access, Zero Trust, Continuous Verification, Device Trust, Certificate-Based Authentication, Mutual TLS, mTLS Support, Client Certificates, Certificate Pinning, Public Key Infrastructure, PKI Integration, Hardware Security Modules, HSM Support, Key Management, Secret Management, Vault Integration, Environment Variables, Configuration Management, Monitoring, Metrics Collection, Performance Monitoring, Security Monitoring, Anomaly Detection, Fraud Detection, Bot Detection, Brute Force Protection, Account Lockout, Suspicious Activity, Security Alerts, Incident Response, Debugging Tools, Token Inspector, Flow Visualization, Developer Console, Test Environments, Sandbox Mode, Mock Servers, Integration Testing, End-to-End Testing, Security Testing, Penetration Testing, Vulnerability Scanning, Compliance Testing, Documentation, API Documentation, Integration Guides, Migration Guides, Best Practice Guides, Security Guidelines, Code Examples, Sample Applications, Reference Implementations, Community Support, Stack Overflow, GitHub Discussions, Issue Tracking, Bug Reports, Feature Requests, Roadmap, Versioning, Deprecation Policy, Migration Paths, Backward Compatibility, Legacy Support, Widely Adopted, Battle Tested, Mature Standard, Proven Technology, Industry Acceptance, Vendor Support, Tool Ecosystem, Testing Tools, Postman Integration, Bruno Support, Insomnia Support, cURL Examples, HTTP Client Support
Website: https://oauth.net/2/
8.34 - JSON Web Token (JWT)
A JSON Web Token (JWT) is a compact, URL-safe token format used to securely transmit information between parties as a JSON object, commonly used for authentication and authorization in web applications.
Allow users to grant access to their applications.
JWT (JSON Web Token) is a compact, self-contained token format used to securely transmit information between parties as a JSON object that can be verified and trusted because it is digitally signed. Defined by RFC 7519, JWTs provide a stateless way to handle authentication and authorization in modern web applications, APIs, and microservices architectures. A JWT consists of three parts separated by dots: a header (containing the token type and signing algorithm), a payload (containing claims or statements about the user and additional metadata), and a signature (used to verify the token hasn’t been tampered with). The entire token is Base64URL-encoded, making it URL-safe and easy to transmit in HTTP headers, URL parameters, or cookies. Unlike opaque tokens that require a server to look up session data in a database, JWTs are self-contained—all the information needed to validate and use the token is embedded within it, allowing stateless authentication where servers don’t need to maintain session state. This makes JWTs particularly valuable in distributed systems, microservices, and mobile applications where scalability and reduced database lookups are important.
JWTs support multiple signing algorithms including HMAC (symmetric signing with a shared secret) and RSA/ECDSA (asymmetric signing with public/private key pairs), with the signature ensuring that the token content hasn’t been modified and verifying the issuer’s identity. The payload contains claims—standardized fields like iss (issuer), sub (subject/user ID), aud (audience), exp (expiration time), iat (issued at), and nbf (not before), along with custom claims for application-specific data like user roles, permissions, or profile information. When a user successfully authenticates, the server generates a JWT and sends it to the client, which then includes this token in subsequent requests (typically in the Authorization: Bearer header). The receiving service can validate the JWT’s signature, check its expiration, and extract claims without needing to query a database or call back to the authentication server, enabling fast, distributed authorization decisions. JWTs have become the de facto standard for OAuth 2.0 access tokens and are central to OpenID Connect ID tokens, used extensively in single sign-on systems, API authentication, mobile app sessions, and serverless architectures. However, because JWTs cannot be easily invalidated before expiration (since they’re stateless), best practices include using short expiration times, implementing token refresh mechanisms, maintaining token blacklists for critical security events, and never storing sensitive information in the payload since Base64 encoding is not encryption and anyone can decode and read the token’s contents.
License: Simplified BSD License
Tags: Authentication, Authorization, Security
Properties: JSON Web Token, Token Format, RFC 7519, IETF Standard, Self-Contained, Stateless, Digitally Signed, Compact Format, URL-Safe, Base64URL Encoded, Three-Part Structure, Header Section, Payload Section, Signature Section, Dot Separated, Header.Payload.Signature, Token Type, Algorithm Specification, Signing Algorithm, HMAC Support, HS256, HS384, HS512, RSA Support, RS256, RS384, RS512, ECDSA Support, ES256, ES384, ES512, PS256, PS384, PS512, Symmetric Signing, Asymmetric Signing, Shared Secret, Public-Private Keys, Digital Signature, Cryptographic Security, Tamper Proof, Integrity Verification, Authentication Token, Authorization Token, Claims-Based, Payload Claims, Registered Claims, Public Claims, Private Claims, Custom Claims, Issuer Claim, Subject Claim, Audience Claim, Expiration Time, Issued At, Not Before, JWT ID, Standard Claims, User Identity, User Roles, Permissions, Metadata, Context Information, Session Data, Token Expiration, Time-Limited, Short-Lived, Long-Lived, Refresh Tokens, Access Tokens, ID Tokens, Token Validation, Signature Verification, Expiration Checking, Issuer Validation, Audience Validation, Clock Skew Tolerance, NBF Validation, Algorithm Verification, Token Decoding, Base64 Decoding, JSON Parsing, Header Parsing, Payload Extraction, Claim Extraction, No Encryption, Readable Payload, Transparent Data, Public Information, No Sensitive Data, PII Warnings, Security Best Practices, Bearer Token, Authorization Header, HTTP Header, Cookie Storage, LocalStorage, SessionStorage, Mobile Storage, Secure Storage, Token Transmission, HTTPS Required, TLS Required, Secure Channel, Man-in-the-Middle Protection, Replay Attack Prevention, Token Theft Protection, XSS Vulnerability, CSRF Considerations, Token Revocation, Blacklist Support, Whitelist Support, Token Invalidation, Logout Handling, Forced Logout, Session Termination, Stateless Authentication, No Server State, No Session Storage, No Database Lookup, Distributed Systems, Microservices, Service-to-Service, API Authentication, REST API, GraphQL, gRPC Support, Mobile Apps, Single Page Applications, Native Apps, Web Applications, Server-Side Rendering, Client-Side Rendering, OAuth 2.0 Integration, OpenID Connect, OIDC ID Tokens, Access Token Format, Token Exchange, Token Delegation, Impersonation, On-Behalf-Of, Nested Tokens, Encrypted JWT, JWE Support, JSON Web Encryption, Content Encryption, Key Encryption, Compact Serialization, JSON Serialization, Flattened Serialization, Multi-Recipient, Key Management, Key Rotation, Key Distribution, JWKS Support, JSON Web Key Set, Public Key Discovery, Well-Known Endpoint, Key ID, Kid Header, Algorithm Header, Type Header, Content Type, Nested JWT, Token Chaining, Token Binding, Proof of Possession, Holder of Key, Certificate Bound, mTLS Binding, DPoP Support, Demonstrating Proof of Possession, Thumbprint, Token Fingerprint, Single Sign-On, SSO Token, Federation, Cross-Domain, CORS Support, Same-Site, Cross-Origin, Domain Restrictions, Scope Claims, Permission Claims, Role Claims, Group Claims, Tenant Claims, Organization Claims, Multi-Tenant, B2B Support, B2C Support, Enterprise Integration, Identity Provider, IdP Issued, Authorization Server, Token Endpoint, Introspection Endpoint, Userinfo Endpoint, Claims Transformation, Claim Mapping, Attribute Mapping, Profile Information, Email Claim, Name Claim, Picture Claim, Locale Claim, Timezone Claim, Phone Number, Address Claim, Custom Attributes, Application Metadata, Device Information, Location Data, IP Address, User Agent, Request Context, Zero Trust, Continuous Verification, Context-Aware, Risk-Based, Adaptive Authentication, Step-Up Auth, Elevated Privileges, MFA Claims, Authentication Method, AMR Claim, ACR Claim, Authentication Context, Assurance Level, Confidence Score, Trust Level, Verification Status, Compliance, GDPR Compliance, Privacy Protection, Data Minimization, Consent Management, Audit Logging, Token Logging, Security Events, Monitoring, Metrics, Performance, Scalability, High Volume, Throughput, Low Latency, Fast Validation, Efficient Processing, Minimal Overhead, Bandwidth Efficient, Small Payload, Compression Support, Token Size, Size Limitations, URL Length Limits, Header Size Limits, Cookie Size Limits, Optimization, Claim Reduction, Minimal Claims, Reference Tokens, Hybrid Approach, Token Cache, Validation Cache, Public Key Cache, Performance Tuning, Library Support, Language Support, JavaScript Libraries, Node.js Support, Python Support, Java Support, .NET Support, Go Support, Ruby Support, PHP Support, Rust Support, Mobile SDKs, iOS Support, Android Support, React Native, Flutter Support, Framework Integration, Express.js, Spring Security, ASP.NET Core, Django, Flask, Laravel, Rails, Passport.js, Auth0 Libraries, Okta SDKs, AWS Amplify, Firebase Auth, Supabase Auth, Testing Tools, Debugger Tools, jwt.io Decoder, Token Inspector, Validation Testing, Unit Testing, Integration Testing, Mock Tokens, Test Tokens, Development Mode, Production Mode, Environment Variables, Configuration Management, Secret Management, Vault Integration, HSM Support, Hardware Security, Key Storage, Secure Enclave, Keychain, Credential Manager, Standards Compliance, RFC Compliance, JOSE Standards, JSON Object Signing, Encryption Standards, Cryptographic Standards, Algorithm Requirements, Security Requirements, Best Current Practice, Security BCP, Threat Model, Attack Vectors, Vulnerabilities, Common Pitfalls, Algorithm Confusion, None Algorithm, Weak Algorithms, Key Exposure, Secret Leakage, Token Leakage, Debug Tokens, Logging Warnings, Error Handling, Exception Handling, Graceful Degradation, Fallback Mechanisms, Backward Compatibility, Forward Compatibility, Version Migration, Legacy Support, Deprecation, Algorithm Deprecation, Security Updates, Patch Management, Vulnerability Disclosure, CVE Tracking, Security Advisories, Industry Standard, Widely Adopted, Battle Tested, Mature Technology, Production Ready, Enterprise Grade, Mission Critical, High Security, Defense in Depth, Layered Security, Token Refresh, Refresh Flow, Silent Refresh, Sliding Expiration, Absolute Expiration, Grace Period, Token Renewal, Automatic Refresh, Refresh Token Rotation, Token Family, Device Binding, IP Binding, Browser Binding, Fingerprinting, Anti-Replay, Nonce Support, JTI Uniqueness, One-Time Use, Idempotency, Documentation, Specification, RFC Documents, Implementation Guides, Best Practices, Security Guidelines, Migration Guides, Code Examples, Sample Code, Reference Implementation, Open Source, Community Support, Stack Overflow, GitHub, Issue Tracking, Feature Requests, Contributions, Ecosystem, Tool Support, Debugger, Validator, Generator, Parser, Encoder, Decoder, Interoperability, Cross-Platform, Cross-Language, Protocol Agnostic, Transport Agnostic, Format Flexibility, Extensible, Custom Headers, Custom Claims, Application Specific, Domain Specific, Industry Specific, Use Case Specific, Versatile, Adaptable, Configurable, Customizable
Website: https://www.jwt.io/
8.35 - HTTP
HTTP (Hypertext Transfer Protocol) is a stateless application-layer protocol that defines how web clients and servers format and exchange requests and responses over the internet.
The foundation of the World Wide Web.
HTTP (Hypertext Transfer Protocol) is a stateless application-layer protocol that defines how web clients and servers format and exchange requests and responses over the internet.
HTTP (Hypertext Transfer Protocol) is the stateless application-layer protocol that underpins the web, defining how clients (like browsers) and servers exchange requests and responses to retrieve or modify resources identified by URLs. It specifies methods (e.g., GET, POST, PUT, DELETE), headers for metadata and content negotiation, and status codes that indicate outcomes. Although HTTP is stateless, features like cookies and authentication headers enable sessions and identity. HTTP traditionally runs over TCP (HTTP/1.1 and HTTP/2 with multiplexing and header compression) and, in its latest version HTTP/3, over QUIC to reduce latency and improve reliability, almost always secured with TLS.
8.36 - HTTP 2.0
HTTP/2 is a binary, multiplexed version of HTTP that uses streams, header compression (HPACK), and optional server push to reduce latency and improve performance over a single TCP connection.
The last version of HTTP that was quickly interated upon.
HTTP/2 is a binary, multiplexed version of HTTP that uses streams, header compression (HPACK), and optional server push to reduce latency and improve performance over a single TCP connection.
HTTP/2 speeds up web communication by sending many HTTP requests and responses concurrently over a single TCP connection using lightweight streams, eliminating the HTTP/1.1 head-of-line blocking at the application layer. It encodes headers efficiently with HPACK to cut bandwidth, supports stream prioritization and flow control so more important resources arrive sooner, and frames messages in a binary format that’s faster and less error-prone to parse. While TLS isn’t required by the spec, it’s almost always used in practice, and HTTP/2 is backward-compatible with existing HTTP semantics (methods, status codes, URIs). It also introduced server push for proactively sending assets—though many platforms now discourage or disable push in favor of alternatives like 103 Early Hints or preload hints.
8.37 - HTTP 3.0
HTTP/3 is the latest HTTP version that runs over QUIC (on UDP), providing multiplexed streams with built-in TLS 1.3 and connection migration to avoid TCP head-of-line blocking and improve performance.
The latest high performance version of HTTP.
HTTP/3 is the latest HTTP version that runs over QUIC (on UDP), providing multiplexed streams with built-in TLS 1.3 and connection migration to avoid TCP head-of-line blocking and improve performance.
HTTP/3 is the newest version of the Hypertext Transfer Protocol that runs over QUIC, a transport built on UDP, to deliver faster and more reliable web transfers—especially on mobile and lossy networks. By multiplexing many streams within one connection, it avoids TCP’s head-of-line blocking, integrates TLS 1.3 by design (with 0-RTT/1-RTT handshakes), and supports connection migration so downloads continue smoothly when a device changes networks. HTTP/3 keeps the same HTTP semantics (methods, status codes, headers) while using binary framing and QPACK header compression for efficiency, and it’s now widely supported by major browsers and CDNs.
8.38 - APIs.json
APIs.json is a machine-readable specification that API providers use to describe their API operations—much like sitemap.xml describes a website. It offers an index of internal, partner, and public APIs that includes not only machine-readable artifacts (OpenAPI, JSON Schema, etc.) but also traditionally human-readable assets such as documentation, pricing, and terms of service.
Describing the surface area of API operations to make discoverable.
APIs.json is a machine-readable specification that API providers use to describe their API operations—much like sitemap.xml describes a website. It offers an index of internal, partner, and public APIs that includes not only machine-readable artifacts (OpenAPI, JSON Schema, etc.) but also traditionally human-readable assets such as documentation, pricing, and terms of service.
License: MIT License
Tags: Discovery
Properties: name, description, images, created, modified, URLs, versions, tags, properties, media types, data, common properties, overlays, includes, networks, maintainers
Website: https://apisjson.org
Standards: JSON Schema
8.39 - API Commons
API Commons is a collection of open-source building blocks for API operations. It began as a machine-readable way to define the parts of an API, and works in concert with APIs.json to translate human-readable aspects of your API program into machine-readable artifacts that can standardize and automate your ecosystem.
Common schema that can be used to describe API operations.
API Commons is a collection of open-source building blocks for API operations. It began as a machine-readable way to define the parts of an API, and works in concert with APIs.json to translate human-readable aspects of your API program into machine-readable artifacts that can standardize and automate your ecosystem.
License: Creative Commons Attribution 3.0 Unported
Tags: Schema, Change, Onboarding, Licensing, Pricing, Support, SDKs
Properties: Change Log, Road Map, Getting Started, Interface Licenses, Pricing, Rate Limits, Tiers, SDKs, Support, Use Cases, and Versioning
Website: https://apicommons.org/
Standards: JSON Schema
8.40 - Microcks Examples
APIExamples format is Microcks’ own specification format for defining examples intended to be used by Microcks mocks.
APIExamples documents are intended to be imported as secondary artifacts only ; thanks to the Multi-Artifacts support.
APIExamples format is Microcks’ own specification format for defining examples intended to be used by Microcks mocks. It can be seen as a lightweight, general purpose specification to solely serve the need to provide mock datasets. The goal of this specification is to keep the Microcks adoption curve very smooth with development teams but also for non developers.
APIExamples files are simple YAML and aim to be very easy to understand and edit. More over, the description is independent from the API protocol! We’re rather attached to describe examples depending on the API interaction style: Request/Response based or Event-driven/Asynchronous.
For ease of use, we provide a JSON Schema that you can download here. Thus, you can integrate it in your code editor and benefit from code completion and validation.
License: Apache 2.0
Tags: Examples
Website: https://microcks.io/documentation/references/examples/
8.41 - vCard Ontology
A vCard is a digital file format used to store and exchange contact information, such as names, phone numbers, email addresses, and addresses, in a standardized, portable way.
Portable contact format.
A vCard is a standardized digital format for storing and exchanging contact information across different applications and devices. It can contain details such as names, phone numbers, email addresses, physical addresses, organization information, URLs, and even photos or custom fields. Commonly shared as .vcf files, vCards allow contacts to be imported or exported easily between email clients, mobile phones, CRM systems, and other address book tools. This makes them a convenient, portable way to transfer personal or business contact details in a consistent, machine-readable format.
License: Simplified BSD License
Tags: Contacts
Properties: BEGIN, END, SOURCE, KIND, XML, FN, N, NICKNAME, PHOTO, BDAY, ANNIVERSARY, GENDER, ADR, TEL, EMAIL, IMPP, LANG, TZ, GEO, TITLE, ROLE, LOGO, ORG, MEMBER, RELATED, CATEGORIES, NOTE, PRODID, REV, SOUND, UID, CLIENTPIDMAP, URL, VERSION, KEY, FBURL, CALADRURI, CALURI, BIRTHPLACE, DEATHPLACE, DEATHDATE, EXPERTISE, HOBBY, INTEREST, ORG-DIRECTORY, CONTACT-URI, CREATED, GRAMGENDER, LANGUAGE, PRONOUNS, SOCIALPROFILE, JSPROP
Website: https://www.w3.org/TR/vcard-rdf/
9 - Tooling
Naftiko is grounded in the Linux, CNCF, and Apache tooling already used across SMB, SME, and enterprise environments. By using the same building blocks as the Naftiko Engine, it plugs in easily to how you operate today.
9.1 - Microcks
Microcks is an open-source, cloud-native tool that turns API specifications (OpenAPI, AsyncAPI, gRPC, GraphQL, and others) into live mocks in seconds and performs contract conformance testing to verify that API implementations meet their contracts.
Mocking and contract testing for APIs using common API artifacts.
Microcks is an open-source, cloud-/Kubernetes-native tool for API mocking and contract testing that turns your existing artifacts—OpenAPI, AsyncAPI, gRPC/Protobuf, GraphQL schemas, Postman collections, SoapUI projects—into live mocks and reusable tests, with CI/CD integrations (Jenkins, GitHub Actions, Tekton). It supports both synchronous and event-driven APIs, connecting to brokers like Kafka, MQTT, AMQP/RabbitMQ, NATS, and WebSocket to validate payloads against your specs. Microcks is a Cloud Native Computing Foundation Sandbox project (accepted June 22, 2023).
License: Apache 2.0
Tags: Testing, Mocking
Properties: API mocking for REST/gRPC/GraphQL/SOAP, event-driven mocking & contract testing for Kafka/MQTT/AMQP-RabbitMQ/NATS/WebSocket (and other brokers), import from OpenAPI/AsyncAPI/Protobuf/GraphQL/Postman/SoapUI, schema-conformance testing with drift detection, smart dynamic mocks with on-the-fly transformations, GitHub Actions & CI/CD integration, Microcks REST API for automation, Kubernetes-native deployment via Helm and Operator, Avro + Schema Registry support on Kafka, organized repository & web UI for managing mocks and tests.
Website: https://microcks.io/
9.2 - Bruno
Bruno is an open-source, offline-first API client that stores collections as plain text files directly on your filesystem and uses Git for version control, providing a lightweight alternative to Postman for testing, debugging, and managing APIs while keeping your data local and private.
Open-source, GitOps, Local API Client
Bruno is an open-source, Git-friendly API client designed for developing, testing, and organizing API requests in a local, file-based environment. Unlike traditional tools like Postman or Insomnia that rely on cloud storage or proprietary formats, Bruno stores collections as plain-text files in a human-readable “.bru” format, making them easy to version, share, and collaborate on using Git. It supports REST, GraphQL, and other request types, along with features such as scripting, environment variables, and testing through lightweight JavaScript assertions. Built to be fast, offline-first, and privacy-respecting, Bruno provides a streamlined and developer-centric experience for managing APIs directly within existing source control workflows.
License: Apache 2.0
Tags: Client, Testing
Properties: Collections, Requests, Responses, Scripts, Tests, Automation
Website: https://www.usebruno.com/
9.3 - Activiti
This is a really useful OpenAPI governance tool using Spectral rules. It was created by the Italian government for anyone to fork and run 100% on GitHub. It is a React app you can download and use locally, then build and publish to GitHub pages. I is really useful for demos and is easy to customize with different JSON or YAML, going beyond just OpenAPI, and assemble different rulesets for different governance purposes. The editor will do YAML or JSON linting with intellisense in the Monaco editor–driven by a single JSON Schema file. It is a really slick editor, and useful to have around.
React application that you can build and run on GitHub pages which acts as JSON / YAML linter with Spectral rules.
GitHub: https://github.com/italia/api-oas-checker
9.4 - Backstage
Backstage is an open-source framework for building developer portals that unifies all your infrastructure tooling, services, and documentation into a centralized software catalog, helping teams manage microservices and ship code quickly while maintaining standards across the organization.
Delivering internal developer portals.
Backstage is an open-source platform (created at Spotify and now a CNCF project) for building internal developer portals that centralize a company’s software ecosystem—services, data pipelines, websites, libraries, infrastructure, and more—into a single, searchable catalog. It provides opinionated building blocks like the Software Catalog, Software Templates (scaffolder) for “golden paths,” TechDocs for docs-as-code, and a rich plugin system so teams can surface CI/CD status, deployments, cost, ownership, and runbooks in one place. The goal is to tame sprawl, standardize workflows, and give developers a self-service hub that speeds delivery while improving reliability and governance.
License: Apache 2.0
Tags: Portals, Catalogs
Properties: Domains, Systems, Components, APIs, Resources, Groups, Locations, Templates
Website: https://backstage.io/
9.5 - Kubernetes
Kubernetes is for automating deployment, scaling, and management of containerized applications in a declarative way.
Automate the deployment, scaling, and management of containerized applications.
Kubernetes is an open-source platform for automating deployment, scaling, and management of containerized applications: you define the desired state in a declarative API (Pods, Deployments, Services, etc.), and controllers continuously reconcile reality to match it. It schedules containers across a cluster, handles service discovery and load balancing, performs rolling updates and rollbacks, manages configuration and secrets, and mounts storage via volumes. Kubernetes is highly extensible—Custom Resource Definitions (CRDs), Operators, and admission webhooks let teams add new APIs and policies—while its ecosystem (Helm, Kustomize, GitOps tools) provides repeatable, cloud-agnostic operations from laptops to multi-cloud.
License: Apache 2.0
Tags: Containers, Deployment, Scaling, Management
Properties: Container orchestration, declarative API and desired state, scheduling and bin packing, service discovery (ClusterIP/DNS), load balancing (Service/Ingress/Gateway API), rolling updates and rollbacks, self-healing (restarts/rescheduling), horizontal pod autoscaling, vertical pod autoscaling, jobs and cron jobs, namespaces and multi-tenancy, RBAC and authentication, network policies, ConfigMaps and Secrets, storage volumes and CSI provisioning, affinity/anti-affinity and topology spread, taints and tolerations, resource requests/limits and quotas, admission control and policy (Pod Security Standards), Custom Resource Definitions and Operators, observability hooks (events/metrics/logs), audit logging, node and cluster autoscaling, Helm/Kustomize/GitOps tooling integration.
Website: https://kubernetes.io/docs/home/
9.6 - kgateway
Kgateway is an open-source API gateway and ingress controller that implements the Kubernetes Gateway API with its own control plane.
Kubernetes-native API gateway and ingress controller.
Kgateway is an open-source, Envoy-powered, Kubernetes-native API gateway and ingress controller that implements the Kubernetes Gateway API with its own control plane, letting teams manage north-south and east-west traffic with modern routing, resiliency, authn/z, and policy extensions—plus emerging “AI gateway” use cases. Originally created by Solo.io as Gloo Gateway, it was donated to the Cloud Native Computing Foundation and accepted as a Sandbox project on March 4, 2025, with ongoing docs, labs, and a GitHub org under the new name.
License: Apache 2.0
Tags: Gateway, Ingress, Kubernetes
Properties: Envoy-based Layer-7 gateway, Kubernetes Gateway API implementation, HTTP and gRPC routing, function-level routing, request/response transformations, header manipulation, external authentication/authorization, local rate limiting, global rate limiting, CORS/CSRF and access logging, TLS termination and SNI, TLS passthrough, mTLS with Istio ambient mesh, retries, timeouts, outlier detection, traffic mirroring, observability and gateway proxy metrics, integrations with Cert-Manager and ExternalDNS, integrations with Istio and Argo Rollouts, AWS ELB integration, support for legacy apps/microservices/serverless, AI gateway features (model traffic management with A/B/canary and failover, prompt enrichment/guarding, API key management, data-loss prevention).
Website: https://kgateway.dev/
9.7 - RabbitMQ
RabbitMQ is an open-source message broker software that implements the Advanced Message Queuing Protocol (AMQP) to accept messages from producers and deliver them to consumers, acting as middleware that enables asynchronous communication between applications by storing messages in queues until they are processed.
Message broker middleware enabling asynchronous communication.
RabbitMQ acts as a message broker that facilitates communication between applications by accepting messages from producers and routing them to consumers through queues. It serves as middleware that reduces server loads and delivery times by decoupling applications, allowing them to communicate asynchronously without waiting for each other to complete tasks. The broker contains two main components: exchanges and queues. Exchanges receive messages from producers and route them to queues based on routing algorithms and binding rules, while queues act as buffers that store messages until receiving applications connect and process them. RabbitMQ supports multiple exchange types including direct exchange (routing based on exact key matching), fanout exchange (broadcasting to all bound queues), topic exchange (pattern-based routing), and headers exchange (routing based on message headers), providing flexible message distribution capabilities.
RabbitMQ is particularly useful for handling long-running background tasks and enabling communication in microservices architectures. Common use cases include processing file uploads (like image scaling or virus scanning) without making users wait, sending notifications through multiple channels (email and push notifications), distributing workload across multiple consumers to balance processing, and managing request spikes that might otherwise cause timeout errors. The system ensures reliable message delivery through acknowledgment mechanisms that verify messages have been received and processed before removing them from queues. RabbitMQ also supports clustering for high availability and fault tolerance, allowing multiple instances to work together with queue replication across nodes. This makes it an essential tool for modern distributed systems where services need to scale independently, handle asynchronous processing efficiently, and maintain resilience without direct interdependencies between components.
License: Mozilla Public License (MPL) 2.0
Tags: Events, Queues, Messages, Brokers
Properties: Reliability, Message Persistence, Message Acknowledgment, Publisher Confirms, Flexible Routing, Multiple Exchange Types, Clustering, High Availability, Fault Tolerance, Message Queuing, Multi-Protocol Support, Scalability, Asynchronous Communication, Delivery Acknowledgment, Message Priority, Durable Queues, Monitoring and Management, Plugin Architecture, Load Balancing, Message TTL, Consumer Acknowledgment
Website: https://www.rabbitmq.com/
9.8 - Apache Ignite
Apache Ignite is a distributed in-memory computing platform that lets you keep data and compute close together for low-latency workloads-.
Distributed in-memory computing platform.
Apache Ignite is a distributed in-memory computing platform that lets you keep data and compute close together for low-latency workloads: it provides an in-memory data grid (key-value and ANSI SQL), a compute grid for colocated processing, and optional durable persistence so datasets can outgrow RAM while still serving from memory. It supports ACID transactions, indexing, continuous queries and streaming, and can act as a high-performance cache in front of existing databases or as a standalone storage/compute layer for OLTP and HTAP use cases. Ignite offers clients for Java, .NET, and C++ (plus thin clients and JDBC/ODBC), integrates with popular tooling, and scales horizontally with partitioned/replicated data, failover, and rebalancing.
License: Apache 2.0
Tags: In-Memory, Distributed, Low-Latency
Properties: In-memory data grid, key-value cache, ANSI SQL querying, distributed joins and indexes, ACID transactions, colocated compute grid, MapReduce-style tasks, continuous queries, data streaming/ingest, optional durable persistence (disk tier), partitioned and replicated caches, affinity-based data colocation, failover and rebalancing, service grid (distributed services), messaging and events, JDBC/ODBC and thin clients, Java/.NET/C++ APIs, cluster discovery and autoscaling hooks, zero-deployment node classloading, metrics and management (JMX/REST).
Website: https://ignite.apache.org/
9.9 - Calcite
Apache Calcite provides a dynamic data management framework Naftiko is using to work across data sources.
SQL parsing, validation, across data sources.
Apache Calcite is a dynamic data management framework that provides a SQL parser/validator, a rich relational algebra, and a cost-based query optimizer that can plan across many heterogeneous data sources. It doesn’t store data or execute queries itself; instead it offers adapters to “federate” sources (JDBC databases, NoSQL, files, streaming) and pushes operations like filters, projections, and joins down to each system where possible. Calcite’s rule-driven optimizer and extensible type system let you define custom operators and schemas, and projects like Apache Druid, Apache Hive, Apache Drill, and Apache Phoenix use it to power their SQL layers. Its Avatica subproject adds a lightweight, database-agnostic remote JDBC/HTTP wire protocol for embedding SQL services.
License: Apache 2.0
Tags: Data, Parsing, Validation, Optimization, Queries
Features: SQL parser, SQL validator, relational algebra, cost-based optimizer, rule-based planner, query rewriting, materialized view rewriting, predicate pushdown, join reordering, federated query planning, adapters for heterogeneous data sources, extensible type system, user-defined functions and operators, schema management and virtual schemas, streaming SQL support, semi-structured data support, trait-based optimization framework, enumerable interpreter, Avatica JDBC/HTTP wire protocol, planner and metadata SPI for custom rules and adapters
Website: https://calcite.apache.org/
9.10 - Git
Git is a distributed version control system that tracks changes in source code during software development, allowing multiple developers to collaborate on projects while maintaining a complete history of all modifications, branches, and versions.
The base version control system used by GitHub, GitLab, and BitBucket
Git is a distributed version control system created by Linus Torvalds in 2005 that tracks changes in files and coordinates work among multiple developers working on the same codebase. Unlike centralized version control systems, Git gives every developer a complete copy of the entire project history on their local machine, allowing them to work offline and commit changes locally before syncing with remote repositories. Git tracks modifications at the file and line level, creating snapshots of the entire project at each commit, which enables developers to review history, compare versions, revert changes, and understand exactly when and why specific code was modified. The system uses cryptographic hashing (SHA-1) to ensure data integrity and prevent corruption, making it extremely reliable for managing source code across teams of any size.
Beyond basic version tracking, Git provides powerful branching and merging capabilities that enable sophisticated development workflows. Developers can create lightweight branches to experiment with new features, fix bugs, or explore different approaches without affecting the main codebase, then merge successful changes back when ready. Git supports various collaboration models including centralized workflows (similar to SVN), feature branch workflows, gitflow workflows, and forking workflows commonly used in open-source projects. The system integrates with platforms like GitHub, GitLab, and Bitbucket that add web-based interfaces, pull request mechanisms, code review tools, and issue tracking. Git’s staging area (index) allows developers to carefully craft commits by selectively choosing which changes to include, while features like rebasing, cherry-picking, stashing, and tags provide fine-grained control over project history and release management. This flexibility and power have made Git the dominant version control system in modern software development, used by individual developers, small teams, and massive open-source projects alike.
License: GPL-2.0-
Tags: Version Control, Change, Source Control
Features: Distributed Version Control, Free and Open Source, GPL-2.0-only License, Branching and Merging, Local Repository, Complete History, Offline Capability, Cryptographic Integrity, SHA-1 Hashing, Snapshot-Based, Fast Performance, Lightweight Branches, Non-Linear Development, Staging Area, Commit History, Remote Repository Support, Push and Pull, Clone Operations, Fork Support, Collaboration-Friendly, Decentralized Architecture, Data Integrity, Atomic Commits, Version Tracking, File History, Change Detection, Diff Generation, Conflict Resolution, Three-Way Merge, Fast-Forward Merge, Rebase Capability, Cherry-Pick, Stashing, Tagging, Release Management, Commit Messages, Author Attribution, Timestamp Tracking, Branch Management, Branch Deletion, Remote Tracking, Multiple Remotes, Distributed Backup, Peer-to-Peer, No Single Point of Failure, Cross-Platform, Command Line Interface, GUI Support, Git Hooks, Pre-Commit Hooks, Post-Commit Hooks, Server-Side Hooks, Submodules, Subtrees, Large File Support, Git LFS, Patch Generation, Patch Application, Email Integration, Bisect Debugging, Blame Annotation, Log Visualization, Graph Visualization, Reflog, Garbage Collection, Pack Files, Delta Compression, Efficient Storage, Network Protocol, HTTP Support, SSH Support, Git Protocol, Smart HTTP, Shallow Clones, Partial Clones, Sparse Checkout, Worktrees, Index Management, Working Directory, Repository Database, Object Store, Blob Objects, Tree Objects, Commit Objects, Tag Objects, Reference Pointers, HEAD Pointer, Detached HEAD, Branch Pointers, Symbolic References, Reflogs, Configuration Files, Global Config, Local Config, User Config, Ignore Files, Gitignore, Attributes, Path Specifications, Revision Syntax, Range Specifications, Ancestry References, Merge Strategies, Recursive Merge, Octopus Merge, Ours Strategy, Subtree Strategy, Conflict Markers, Merge Tools, External Diff Tools, Git Attributes, Line Ending Normalization, Text vs Binary Detection, Filter Drivers, Smudge Filters, Clean Filters, Archive Generation, Bundle Creation, Maintenance Commands, Fsck Integrity Check, Prune Operations, Repack Operations, Statistics, Shortlog, Describe Command, Show Command, Status Reporting, Untracked Files, Modified Files, Staged Files, Deleted Files, Renamed Files, Moved Files, Copy Detection, Similarity Detection, Whitespace Handling, Color Output, Pager Support, Aliases, Command Shortcuts, Autocomplete, Shell Integration, Credential Management, Credential Helpers, Password Caching, SSH Key Support, GPG Signing, Signed Commits, Signed Tags, Verification, Trust Chain, Web Interface Support, Repository Hosting, GitHub Integration, GitLab Integration, Bitbucket Integration, Self-Hosting, Gitolite, Bare Repositories, Workflow Support, Gitflow Workflow, Feature Branch Workflow, Forking Workflow, Centralized Workflow, Pull Request Model, Code Review Integration, Issue Tracking Integration, Continuous Integration Support, Automation Friendly, Scripting Support, API Access, Git Server, Git Daemon, Smart Protocol, Dumb Protocol, Archive Serving, Repository Mirroring, Alternates, Reference Repositories, Linked Worktrees, Sparse Index, File System Monitor, Multi-Pack Index, Commit Graph, Bitmap Index, Protocol V2, Partial Clone Filters, Object Filters, Blob Filters, Tree Filters, Background Maintenance, Incremental Repack, Geometric Repack, Write Commit Graph, Prefetch, Loose Objects, Object Database, Reference Database
Website: https://git-scm.com/
9.11 - Crossplane
Crossplane is an open-source framework for building cloud-native control planes that extends Kubernetes to orchestrate and manage applications and infrastructure across any cloud provider or environment without needing to write code, allowing platform engineers to create custom APIs that enable self-service infrastructure provisioning with built-in policies and guardrails.
Establish a control plane for infrastructure and APIs.
Crossplane is a CNCF project that turns Kubernetes into a universal control plane for infrastructure and platform APIs: cloud resources (databases, buckets, networks), SaaS, and even other clusters are modeled as Kubernetes custom resources and reconciled by providers for AWS, Azure, GCP, and more. Platform teams define higher-level, opinionated abstractions using XRDs and Compositions, publish them as installable packages, and expose safe “claims” so app teams can self-serve PostgreSQLs, queues, or whole app platforms via the same Kubernetes API they already use. This enables GitOps-friendly, declarative, multi-cloud provisioning with fine-grained RBAC, drift detection, and the ability to build bespoke internal platforms without writing bespoke controllers.
License: Apache 2.0
Tags: Control Plane, Infrastructure, Platform, APIs
Properties: Kubernetes-native control plane (CRDs, controllers), multi-cloud and SaaS provisioning via Providers, Managed Resources, Composite Resource Definitions (XRDs), Compositions, Claims (XRCs), Composition Functions, declarative GitOps workflows, fine-grained RBAC and namespace isolation, drift detection and continuous reconciliation, secret propagation to workloads, health/status via Conditions, policy and validation via OpenAPI schemas, package manager (OCI) for providers and compositions, versioning and upgrades with rollback, observability (events, metrics, logs), pluggable provider ecosystem (including Terrajet), cross-resource references and dependency ordering, cross-namespace publishing and claim binding, works with Helm/Kustomize/Argo CD/Flux
Website: https://www.crossplane.io/
9.12 - Docker
Docker is an open-source platform that allows developers to build, ship, and run applications in lightweight, portable containers that package code and all its dependencies together, enabling software to run quickly and reliably across different computing environments from development to production.
Individual unit of compute for delivering applications and integrations.
Docker provides a platform for developing, shipping, and running applications by packaging them into standardized units called containers. Containers are lightweight, standalone, executable packages that include everything needed to run an application—code, runtime, system tools, libraries, and settings. Docker enables developers to separate applications from infrastructure, allowing them to deliver software quickly and consistently. The platform uses a client-server architecture where the Docker client communicates with the Docker daemon, which handles the heavy lifting of building, running, and distributing containers. Containers are isolated from each other and the host system, yet they share the operating system kernel, making them much more efficient than traditional virtual machines. This means multiple containers can run simultaneously on a server, with containerized software running the same way regardless of the infrastructure—whether it’s on a local development machine, in a data center, or in the cloud.
Docker streamlines the entire development lifecycle by providing tools and workflows for continuous integration and continuous delivery (CI/CD). Developers can write code locally using containers that provide standardized environments, share their work with colleagues, push applications to test environments, and deploy to production with confidence that the application will work the same everywhere. Docker automates repetitive tasks like environment setup, dependency management, and image building, allowing developers to focus on writing code rather than troubleshooting configuration issues. The platform includes Docker Hub, a public registry containing thousands of pre-built container images that developers can use as starting points for their applications, and Docker Compose for defining and running multi-container applications. By improving resource utilization and enabling teams to ship code faster—Docker users ship software seven times more frequently than non-Docker users—Docker helps organizations reduce costs, accelerate development cycles, and build modern applications using microservices architectures.
License: Apache 2.0
Tags: Containers, Compute
Properties: Kubernetes-native control plane (CRDs, controllers), multi-cloud and SaaS provisioning via Providers, Managed Resources, Composite Resource Definitions (XRDs), Compositions, Claims (XRCs), Composition Functions, declarative GitOps workflows, fine-grained RBAC and namespace isolation, drift detection and continuous reconciliation, secret propagation to workloads, health/status via Conditions, policy and validation via OpenAPI schemas, package manager (OCI) for providers and compositions, versioning and upgrades with rollback, observability (events, metrics, logs), pluggable provider ecosystem (including Terrajet), cross-resource references and dependency ordering, cross-namespace publishing and claim binding, works with Helm/Kustomize/Argo CD/Flux
Website: https://www.docker.com/
9.13 - Eclipse
Eclipse is a free, open-source integrated development environment (IDE) primarily used for Java development, though it supports multiple programming languages through its extensible plugin architecture, and serves as a platform for building development tools across various domains.
Integrated development environment for developers.
Eclipse is a free, open-source integrated development environment (IDE) that originated as an IBM project in 2001 and is now managed by the Eclipse Foundation. While it’s primarily known for Java development, Eclipse functions as a comprehensive development platform that supports multiple programming languages including C/C++, Python, PHP, JavaScript, and many others through its extensive plugin architecture. The IDE provides core development features such as syntax highlighting, code completion, refactoring, debugging, version control integration, and build automation. Eclipse’s modular design allows developers to customize their environment by installing plugins from the Eclipse Marketplace, transforming it into a specialized tool for web development, mobile development, data science, or embedded systems programming.
Beyond serving as an IDE, Eclipse operates as a broader ecosystem and platform for building development tools and applications. The Eclipse Foundation hosts hundreds of open-source projects spanning diverse domains including modeling tools (Eclipse Modeling Framework), IoT development (Eclipse IoT), cloud-native development, automotive software, and scientific research tools. Eclipse’s Rich Client Platform (RCP) allows developers to build standalone desktop applications using the same framework that powers the IDE itself. Major companies and organizations use Eclipse not only as a development environment but also as a foundation for creating their own custom development tools and enterprise applications. The platform’s extensibility, open governance model, and strong community support have made it a cornerstone of the open-source development ecosystem, particularly in enterprise Java development, embedded systems, and academic environments.
License: Eclipse Public License (EPL)
Tags: Integrated Developoment Environments, Plugins
Properties: Open Source, Free, Cross-Platform, Extensible Plugin Architecture, Java-Based, Workspace-Centric, Multi-Language Support, Modular Design, Eclipse Public License, Incremental Compilation, Code Refactoring, Syntax Highlighting, Code Completion, Integrated Debugger, Version Control Integration, Build Automation, Project Management, Rich Client Platform, SWT/JFace Framework, Eclipse Marketplace, Perspective-Based UI, View-Based Architecture, Team Collaboration, Remote Debugging, JDT (Java Development Tools), CDT (C/C++ Development Tools), PDT (PHP Development Tools), Eclipse Modeling Framework, Web Tools Platform, Server Integration, Tomcat Support, GlassFX Support, Java EE Development, Advanced Code Analysis, Quick Fixes, Code Templates, File System Workspace, Metadata Management, External File Modification Support, Code Navigation, Type Hierarchy, Call Hierarchy, Search Functionality, Multi-Editor Support, Split Panes, Content Assist, Error Markers, Warning Indicators, Problem View, Console Integration, Task Management, Bookmark Support, Working Sets, Launch Configurations, Ant Integration, Maven Support, Gradle Support, JUnit Integration, Test Runner, Code Coverage, Profiling Support, Memory Analysis, Thread Debugging, Breakpoint Management, Expression Evaluation, Hot Code Replace, Step Debugging, Variable Inspection, Watch Expressions, Conditional Breakpoints, Exception Breakpoints, Method Breakpoints, Import Organization, Code Formatting, Save Actions, Editor Customization, Key Bindings, Color Themes, Font Configuration, Plugin Development Environment, OSGi Framework, Equinox Runtime, Update Manager, Automatic Updates, Eclipse Foundation Governance, Community-Driven Development, Vendor-Neutral Platform, Enterprise Adoption, Educational Use, Academic Support, Documentation Generation, JavaDoc Integration, XML Editing, JSON Support, Properties File Editing, Resource Management, Build Path Configuration, Library Management, Classpath Configuration, Source Attachment, JavaFX Support, Swing Support, AWT Support, Database Explorer, SQL Editor, Query Execution, Schema Visualization, Data Export/Import, GUI Designer, Visual Editor, Drag-and-Drop UI Design, Form Editor, Manifest Editor, Plugin Manifest Support, Feature Configuration, Product Configuration, P2 Repository, Eclipse RCP Applications, Standalone Application Framework, Customizable Toolbars, Customizable Menus, Context Menus, Quick Access, Command Framework, Handler Framework, Extension Point System, Contribution System, Service Registry, Event Notification, Job Scheduling, Progress Reporting, Preference Store, Dialog Framework, Wizard Framework, Internationalization Support, Accessibility Features, Screen Reader Support, Keyboard Navigation, High DPI Support, Wayland Support, GTK Integration, Windows Native, macOS Support, Linux Support, Multi-Monitor Support, Detachable Views, Maximizable Views, Minimizable Views, Fast Views, Sticky Views, Shared Views, Editor Area, Outline View, Package Explorer, Project Explorer, Navigator View, Properties View, Problems View, Console View, Progress View, Error Log, Search Results View, Git Integration, SVN Support, CVS Support, Mercurial Support, History View, Compare Editor, Merge Tool, Conflict Resolution, Annotation Support, Blame View, Branch Management, Remote Repository Access, Commit Dialog, Push/Pull Operations, Stash Management, Tag Management, Patch Creation, Diff Generation, Local History, File Comparison, Three-Way Merge, Code Mining, Parameter Names, Method Separators, Implementation Links, Reference Count, Code Lens, Inline Annotations, Hover Information, Tooltip Support, Content Type Detection, File Associations, Text Encoding Support, Line Ending Normalization, Spell Checking, Code Folding, Block Selection, Column Mode, Multiple Cursors, Find/Replace, Regular Expression Search, File Search, Text Search, Java Search, References Search, Declarations Search, Implementors Search, Read Access Search, Write Access
Website: https://eclipseide.org/
Plugins: https://marketplace.eclipse.org/
9.14 - JetBrains
JetBrains is a software development company that creates intelligent development tools and integrated development environments (IDEs) for software developers and project managers, including popular products like IntelliJ IDEA for Java development, PyCharm for Python, WebStorm for JavaScript, and the Kotlin programming language.
Integrated development environment for developers.
JetBrains is a global software company that specializes in creating intelligent, productivity-enhancing development tools for software developers and project managers. The company develops a comprehensive suite of integrated development environments (IDEs) tailored to specific programming languages and platforms, including IntelliJ IDEA (for Java and Kotlin), PyCharm (for Python), WebStorm (for JavaScript and TypeScript), PhpStorm (for PHP), GoLand (for Go), Rider (for .NET), CLion (for C and C++), RustRover (for Rust), RubyMine (for Ruby and Rails), and DataGrip (for databases). Beyond IDEs, JetBrains created the Kotlin programming language in 2011, which has become the official programming language for Android development and runs on the Java Virtual Machine. The company serves approximately 11.4 million recurring active users worldwide, including 88 of the Fortune Global Top 100 companies.
In addition to their IDE products, JetBrains develops team collaboration and development tools including TeamCity (a continuous integration and continuous delivery server), YouTrack (project management software), and various .NET tools like ReSharper (an extension for Visual Studio), dotCover, dotMemory, and dotTrace. The company has integrated AI capabilities across its tools, including AI Assistant with chat assistance and Junie, their coding agent that uses models like GPT-5 to help developers with tasks beyond just writing code—including code review, reasoning, and system design. JetBrains operates on a subscription-based business model and maintains its independence as a private company that has never raised external capital. The company is headquartered in Prague, Czech Republic (with corporate headquarters in Amsterdam), has offices in China, Europe, and the United States, and employs over 2,800 people globally while providing extensive support to educational institutions and the open-source community.
License: Commercial LIcense
Tags: Integrated Developoment Environments, Plugins
Properties: Intelligent Code Completion, Advanced Refactoring, Static Code Analysis, Deep Code Understanding, Context-Aware Suggestions, Built-in Version Control, Integrated Debugger, Code Navigation, Framework Support, Database Tools, Terminal Integration, Plugin Marketplace, Cross-Platform, Multi-Language Support, Smart Code Inspection, Quick Fixes, Live Templates, Code Generation, Test Runner Integration, Build Tool Integration, Decompiler, HTTP Client, UML Diagrams, Duplicate Detection, Dependency Analysis, Code Coverage, Profiling Tools, Maven/Gradle Support, Spring Framework Integration, Java EE Support, Kotlin Support, Groovy Support, Scala Support, Android Development Support, Remote Development, Collaborative Development, AI Assistant, Diff and Merge Tools, Task Management, Local History, Scratch Files, Bookmarks, TODO Management, Customizable Keymaps, Theme Support, Split Editor, Multiple Cursors, Column Selection, Code Folding, Parameter Hints, Breadcrumbs Navigation, Search Everywhere, Structural Search and Replace, Language Injection, Postfix Completion, Intention Actions, Smart Step Into, Expression Evaluation, Hot Swap, Memory View, Thread Debugging, Conditional Breakpoints, Docker Integration, Kubernetes Support, REST Client, SQL Console, Query Plan Analysis, Schema Navigation, Data Export/Import, GUI Designer, Swing/JavaFX Support, Lightweight IDE Mode, Power Save Mode, Distraction-Free Mode, Presentation Mode, File Watchers, External Tools Integration, Command Line Launcher, JVM Profiler, Memory Indicator, Performance Monitoring, Resource Bundles Editor, Properties Files Support, XML/JSON Editing, Markdown Preview, Regular Expression Tester, HTTP Request Testing, Code Style Enforcement, Import Optimization, Unused Code Detection, Null Pointer Analysis, Exception Breakpoints, Method Breakpoints, Field Watchpoints, Class Hierarchy Navigation, Call Hierarchy, Type Hierarchy, File Structure View, Project Structure Management, Module Management, Library Management, SDK Configuration, Compiler Settings, Annotation Processing, Bytecode Viewer, Heap Dump Analysis, Thread Dump Analysis, Educational Features, Code With Me, Settings Sync, IDE Services Integration, License Vault Support
Website: https://www.jetbrains.com/idea/
Plugins: https://plugins.jetbrains.com/
9.15 - Spring AI
The Spring AI project aims to streamline the development of applications that incorporate artificial intelligence functionality without unnecessary complexity.
Providing MCP server using Java
The project draws inspiration from notable Python projects, such as LangChain and LlamaIndex, but Spring AI is not a direct port of those projects. The project was founded with the belief that the next wave of Generative AI applications will not be only for Python developers but will be ubiquitous across many programming languages.
License: Apache 2.0
Tags: Artificial Intelligence, MCP Servers
Website: https://docs.spring.io/spring-ai/reference/index.html
9.16 - VSCode
Visual Studio Code (VS Code) is a free, open-source code editor developed by Microsoft that provides developers with features like syntax highlighting, intelligent code completion, debugging, version control integration, and extensibility through plugins for writing and editing code across multiple programming languages.
Integrated development environment for developers.
Visual Studio Code (VS Code) is a lightweight yet powerful source code editor that provides developers with a comprehensive development environment for writing, editing, and debugging code across virtually any programming language. The editor offers intelligent code completion through IntelliSense, which provides smart completions based on variable types, function definitions, and imported modules. VS Code includes built-in syntax highlighting for numerous languages, code navigation features that allow developers to quickly jump to definitions and references, and integrated Git version control that enables developers to commit, push, pull, and manage repositories directly from the editor. The editor also includes a powerful search and replace functionality with support for regular expressions, multi-cursor editing for simultaneous changes across multiple lines, and code formatting tools that help maintain consistent code style.
VS Code’s extensibility is one of its most powerful features, with a vast marketplace of extensions that add support for additional programming languages, frameworks, themes, debuggers, and tools. The integrated debugger allows developers to set breakpoints, inspect variables, view call stacks, and step through code execution for multiple languages without leaving the editor. VS Code supports terminal integration, providing access to command-line tools directly within the editor interface, and includes a split-view editor that allows developers to work on multiple files side-by-side. The editor is cross-platform, running on Windows, macOS, and Linux, and offers remote development capabilities that enable developers to work on code hosted on remote machines, containers, or the Windows Subsystem for Linux (WSL). These features combine to create a fast, flexible development environment that adapts to diverse workflows and project requirements.
License: Microsoft proprietary license
Tags: Integrated Developoment Environments, Plugins
Properties: Lightweight, Cross-platform, Syntax Highlighting, IntelliSense Code Completion, Integrated Debugger, Git Integration, Integrated Terminal, Extension Marketplace, Multi-language Support, Code Refactoring, Bracket Matching, Auto-indentation, Code Snippets, Customizable Themes, Customizable Keyboard Shortcuts, Split Editor View, Command Palette, Multi-cursor Editing, Code Folding, Search and Replace, Live Share Collaboration, Remote Development, Task Runner, Version Control, Free and Open Source
Website: https://code.visualstudio.com/
Extensions: https://marketplace.visualstudio.com/vscode
10 - Glossary
A glossary of the words used to describe the different aspects of integrations, ensuring there is a common vocabulary in use when developing capabilities that are used with the Naftiko Framework, Engine, and the Fabric.
10.1 - Domain
A particular field of thought, activity, or interest, especially one over which someone has control, influence, or rights.
In Domain-Driven Design (DDD), a “domain” is the specific subject area or sphere of knowledge that an application is built to serve, encompassing all the related business logic, rules, and processes. It’s not about the technology, but about the core business problem the software is trying to solve
10.2 - AI Integration
AI integration is the process of embedding artificial intelligence capabilities—such as machine learning, natural language processing, computer vision, or predictive analytics—into existing systems, applications, workflows, or products to enhance their functionality, automation, and decision-making.
AI integration is the process of embedding artificial intelligence capabilities—such as machine learning, natural language processing, computer vision, or predictive analytics—into existing systems, applications, workflows, or products to enhance their functionality, automation, and decision-making.
It typically involves connecting AI models or services (like GPT, image recognition APIs, or custom ML models) to software via APIs, SDKs, or data pipelines so the system can analyze data, make predictions, or interact intelligently with users.
In practice, AI integration can mean:
Enhancing automation — letting systems take over repetitive or complex decision processes.
Improving user experience — using chatbots, recommendation engines, or personalization models.
Optimizing operations — integrating AI into analytics, monitoring, or workflow systems to improve efficiency and reduce cost.
Creating new capabilities — such as predictive maintenance, fraud detection, or adaptive learning environments.
It’s often a key stage of digital transformation, connecting AI systems with enterprise infrastructure (e.g., CRM, ERP, or APIs) to make data and intelligence work seamlessly across the organization.
10.3 - Agentic
Agentic: having the capacity for agency; characterized by self-directed, intentional, goal-oriented action and the ability to make choices and exert influence.
10.4 - AI
AI (Artificial Intelligence): the capability of machines or software to perform tasks that typically require human intelligence, such as learning, reasoning, problem-solving, perception, and language understanding.
10.5 - AI-Driven
Powered or guided primarily by artificial intelligence to perform tasks or make decisions.
10.6 - API Discovery
API discovery is the process of finding and understanding available APIs—including their endpoints, capabilities, versions, and access details—often via catalogs, registries, or machine-readable specifications.
10.7 - API Integration
API integration is the process of connecting two or more software systems through their application programming interfaces to enable seamless data exchange and shared functionality.
10.8 - Application Integration
Application integration is the process of connecting independent software applications so they can communicate, share data, and coordinate processes, enabling them to function as a cohesive system.
10.9 - Budgets
Financial plans that estimate and allocate income and expenses over a period; also, the amounts of money set aside for specific purposes. As a verb (third-person singular), “budgets” means plans or allocates spending within limits.
10.10 - CCPA
CCPA (California Consumer Privacy Act) is a California state privacy law that grants residents rights over their personal information and imposes obligations on businesses regarding its collection, use, and sale.
10.11 - Cloud Integration
Cloud integration is the process of connecting cloud-based and on-premises applications, services, and data so they can exchange information and operate as a unified system.
10.12 - Code Generation
Code generation is the automated process of producing program code—source or machine code—from higher-level descriptions or intermediate representations, typically as the compiler phase that translates IR into target code.
10.13 - Compliance
The act of conforming to or following rules, standards, laws, or requests.
10.14 - Costs
Expenses incurred to obtain or produce something; as a verb, requires payment or entails a loss.
10.15 - Data Integration
Data integration is the process of combining data from disparate sources and formats into a unified, consistent view for analysis and operational use.
10.16 - Databases
Databases are organized collections of data, generally stored and accessed electronically, that support efficient retrieval, updating, and management.
10.17 - DevOops
A humorous term (DevOps + “oops”) for DevOps mistakes—like misconfigurations or bad releases—that cause incidents or outages.
10.18 - EDI
Electronic data interchange: the computer-to-computer exchange of standardized business documents between organizations.
Equity, diversity, and inclusion: an organizational framework to promote fairness, representation, and belonging across differences.
10.19 - Event-Driven
Event-driven: a computing paradigm where a system’s flow is determined by events—such as user actions, messages, or sensor outputs—with handlers that react to those events.
10.20 - Gateways
Gateways (plural of gateway): entrances or means of access; figuratively, routes to achieve or obtain something; in computing, devices or software that connect and route data between different networks or systems.
10.21 - GDPR
GDPR is the European Union’s General Data Protection Regulation, a law that sets rules for how organizations collect, use, protect, and transfer the personal data of individuals in the EU/EEA.
10.22 - GitOps
GitOps is an operational model that manages infrastructure and applications declaratively using Git as the single source of truth, with automation continuously reconciling the desired state in Git with the actual running systems.
10.23 - Governance
The system of rules, structures, and practices by which an organization, state, or community is directed, controlled, and held accountable.
10.24 - GraphQL
GraphQL is a query language for APIs and a runtime that executes those queries, allowing clients to request exactly the data they need from a single endpoint.
10.25 - Integrations
Acts or processes of combining or coordinating separate parts, systems, or groups so they function as a whole.
10.26 - KYC
KYC (Know Your Customer) is the due‑diligence process by which businesses, especially financial institutions, verify a customer’s identity and assess risk to comply with anti‑money laundering and counter‑terrorist financing regulations.
10.27 - MCP
Model Context Protocol (MCP) is an open-source standard introduced by Anthropic that enables AI applications to securely connect to external data sources, tools, and systems through a standardized protocol.
10.28 - Microservices
Microservices are an architectural approach that structures an application as a collection of small, loosely coupled, independently deployable services, each focused on a specific business capability and communicating over lightweight protocols.
10.29 - Modernization
Modernization is the process of updating or transforming something—such as a system, organization, or society—to align with contemporary standards, technologies, and practices.
10.30 - Observability
The extent to which a system’s internal state can be inferred from its external outputs.
10.31 - Open-Source
Software whose source code is publicly available for anyone to use, study, modify, and redistribute, typically under an open-source license.
10.32 - OpenAPI
OpenAPI is a language-agnostic, vendor-neutral specification for describing and documenting HTTP APIs (formerly the Swagger Specification).
10.33 - Operations
Operations: the activities and processes involved in running something (especially the day-to-day work of a business or organization); more broadly, procedures that act on inputs to produce results (as in mathematics or computing); also, planned actions or missions (military) or surgical procedures (medicine).
10.34 - Platforms
Platforms: raised level surfaces for standing or staging; more broadly, the underlying system or environment that supports applications or services (including social media); also, a political party’s stated policies, or shoes with thick, high soles.
10.35 - Registries
Official lists or databases of records, typically maintained by an authority.
10.36 - Risk
The possibility of loss, harm, or other adverse outcome.
10.37 - SaaS
SaaS (Software as a Service) is a cloud computing model where software applications are hosted by a provider and delivered over the internet on a subscription or pay‑as‑you‑go basis, with the provider managing infrastructure, maintenance, and updates.
10.38 - Schema
A schema is a structured framework or blueprint that organizes and represents information and the relationships among its parts.
10.39 - Security
The state of being free from danger, threat, or anxiety; safety.
Measures, systems, or personnel used to protect people, property, or information.
A financial instrument (e.g., stock or bond) representing ownership or debt.
Property pledged as collateral to secure a loan.
10.40 - Standards
Standards:
Levels of quality or achievement regarded as acceptable or desirable.
Established rules, specifications, or criteria used for measurement or judgment.
Widely recognized, frequently performed songs (especially in jazz or popular music).
Flags or emblems serving as symbols of a group or nation.
10.41 - Strategy
A plan of action or set of guiding choices designed to achieve long-term goals, especially under conditions of uncertainty or competition.
10.42 - Virtualizations
Virtualizations: the processes or instances of creating virtual versions of computing resources—such as servers, operating systems, storage, or networks—abstracted from underlying physical hardware.
10.43 - Access Control
Access control is the set of policies and mechanisms that decide who (or what) can do what on which resource—and under which conditions. It limits access to systems, data, APIs, devices, or physical spaces so only authorized subjects can perform permitted actions, implementing least-privilege and auditability.
Access control is the set of policies and mechanisms that decide who (or what) can do what on which resource—and under which conditions. It limits access to systems, data, APIs, devices, or physical spaces so only authorized subjects can perform permitted actions, implementing least-privilege and auditability.
10.44 - Advertising
Advertising is paid, deliberate communication from a sponsor to an audience to influence awareness, attitudes, or behavior—most often to drive sales or adoption. Advertising aims to drive awareness, consideration, and conversion, running across TV, radio, print, as well as digital channels like search, social, display, video/CTV, retail media, podcasts/audio, and influencer/sponsorship placements.
Advertising is paid, deliberate communication from a sponsor to an audience to influence awareness, attitudes, or behavior—most often to drive sales or adoption. Advertising aims to drive awareness, consideration, and conversion, running across TV, radio, print, as well as digital channels like search, social, display, video/CTV, retail media, podcasts/audio, and influencer/sponsorship placements.
10.45 - Agents
An agent is an entity—human, software, or other—that perceives its environment, makes decisions, and acts to achieve goals; in computing and AI, it’s typically an autonomous program that observes inputs, reasons or plans, and takes actions via tools or APIs (sometimes coordinating with other agents), while in economics and law it refers to a person acting on behalf of a principal, and in broader usage it can mean any substance or mechanism that produces an effect.
Agentic AI refers to AI systems designed to pursue goals autonomously: they interpret objectives, plan multi-step actions, call tools/APIs, and adapt using memory and feedback loops (reflection, self-critique, retries). Unlike passive “assistants” that answer prompts, agentic systems take initiative, decompose tasks, coordinate with other agents, and monitor progress toward measurable outcomes.
10.46 - Agents
An agent is an entity—human, software, or other—that perceives its environment, makes decisions, and acts to achieve goals; in computing and AI, it’s typically an autonomous program that observes inputs, reasons or plans, and takes actions via tools or APIs (sometimes coordinating with other agents), while in economics and law it refers to a person acting on behalf of a principal, and in broader usage it can mean any substance or mechanism that produces an effect.
An agent is an entity—human, software, or other—that perceives its environment, makes decisions, and acts to achieve goals; in computing and AI, it’s typically an autonomous program that observes inputs, reasons or plans, and takes actions via tools or APIs (sometimes coordinating with other agents), while in economics and law it refers to a person acting on behalf of a principal, and in broader usage it can mean any substance or mechanism that produces an effect.
© 2025–2026 Naftiko | CC BY 4.0 |All Rights ReservedPrivacy Policy