This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

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.

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