Skip to main content
This section helps you create your first custom connector for the Grand Central integration platform.

​
Overview

Custom connectors integrate your applications and services with the Grand Central integration platform. You build connectors with Apache Camel-K, and they run on Kubernetes to provide a scalable and reliable integration solution. Platform access:
  • Azure Portal - Access Azure resources and runtimes
  • GitHub organization - Your installation-specific organization at https://github.com/bb-ecos-{installation}. Your Backbase onboarding team or project manager provides the exact URL.
  • Support Portal - Create tickets and get help
Monitoring and observability:
  • DataDog - Application monitoring and logs
  • Grafana - Metrics and dashboards
Development tools:

​
Before you start checklist

Before creating your first connector, ensure:
  • You have access to the self-service repository. This is the source of truth for building Custom Connectors.
  • Your GitHub account is connected to the organization
  • You’ve installed Java JDK 11+, Maven 3.6+, and Git
  • You understand basic Git workflows (clone, branch, commit, PR)
  • You have a clear understanding of the integration you want to build
  • You know which external APIs/services you’ll be integrating with
  • (Optional) You have Azure access if you need to deploy to runtimes
  • (Optional) You have DataDog/Grafana access if you need to monitor
Need help with any of these? See the Learning Resources section below.

​
Prerequisites

Before you begin, ensure you have:
  • Access to the self-service repository - You need to be added as a team member with appropriate permissions
    • If you don’t have access, contact your Backbase Onboarding team or project manager to request access
    • Manage access through the team_members section in self-service.tfvars
    • For additional user seats, create a support ticket
  • GitHub account - Connected to the organization
  • Azure access (optional) - For runtime access to dev, staging, test, or UAT environments
    • Required if you need to deploy or monitor connectors in runtime environments
    • Grand Central roles in self-service.tfvars grant this access
  • Basic understanding of:
    • Git and GitHub workflows - Git documentation | GitHub Guides
    • Integration patterns - Familiarity with common integration patterns (request/response, pub/sub, etc.)
    • REST APIs - Understanding of REST principles and HTTP methods
    • Apache Camel (recommended) - Basic knowledge of Apache Camel and route definitions
Don’t have access yet? Contact your Backbase onboarding team or project manager to request access to the self-service repository. They can add you to the team_members section in self-service.tfvars.

​
Learning resources

If you need to brush up on any prerequisites:

​
Your first connector

Follow these steps to create your first connector repository.

​
Request repository creation

To create a new connector, you need to request a repository through the self-service process:
  1. Navigate to the self-service repository and create a new branch.
  2. Edit self-service.tfvars to add your connector repository definition.
  3. Create a pull request targeting the main branch.

​
Define your connector repository

Add your connector definition to the repositories section in self-service.tfvars: 
repositories = {
  "my-custom-connector" = {
    repository_topics = [
      "grandcentral",
      "connector",
      "integration",
      "camel-k"
    ]
    enable_branch_protection = true
    enforce_admins = true
    default_branch = "develop"
    require_branch_up_to_date = true
    protected_branches = ["main", "develop"]
    required_status_checks = ["Validate pull request / Verify Maven project"]
    repository_init_from_zip = {
      name    = "grandcentral-connector-template"
      version = "2.0.5"
    }
    repository_visibility = "private"
  }
}
Key configuration options:
  • repository_init_from_zip: Automatically initializes your repository from the connector template
    • name: Use "grandcentral-connector-template" for connector projects
    • version: Specify the template version (check for the latest available version)
  • repository_topics: Add relevant tags for discoverability
  • protected_branches: Branches that require pull request reviews before merging
  • required_status_checks: CI/CD checks that must pass before merging

​
Wait for repository provisioning

After you merge the pull request:
  1. The pipeline automatically provisions your repository.
  2. The pipeline initializes the repository from the connector template.
  3. You receive access to the repository based on your team permissions.

​
Clone and explore

Once your repository is created: 
git clone <your-organization>/my-custom-connector.git
cd my-custom-connector
The template includes:
  • Maven project structure - Standard Java/Maven setup
  • Camel-K integration routes - Pre-configured integration patterns
  • CI/CD pipelines - Automated build and validation
  • Documentation templates - README and configuration guides

​
Understanding the template structure

The connector template provides a solid foundation: 
my-custom-connector/
├── src/
│   └── main/
│       └── resources/
│           └── application.properties  # Configuration
│           └── routes/                # Camel routes
├── pom.xml                            # Maven dependencies
├── README.md                          # Project documentation
└── .github/
    └── workflows/                     # CI/CD pipelines

​
About the connector template

The connector template (grandcentral-connector-template) provides:
  • Pre-configured Apache Maven project structure
  • Sample Apache Camel routes and integration patterns
  • CI/CD pipeline configuration
  • Health check endpoints
  • Logging configuration
Template versions:
  • Check the version used by existing connector repositories in your installation, and align with your team’s choice.
  • The repository is initialized from the template automatically when it is created.

​
Next steps

Now that you have your connector repository set up:
  1. Review the template code - Understand the structure and patterns
  2. Read the Build guide - Learn how to develop and build your connector
  3. Configure your integration - Define your API endpoints and data mappings
  4. Test locally - Use the development tools to test your connector

​
Getting help

  • Support Portal: Create a support ticket for access requests or platform issues
  • Documentation: Check the Build, Run, and Monitor guides for detailed information
  • Team Support: Contact the team or project manager onboarding you.
  • GitHub Issues: Use the repository’s issue tracker for technical questions

​
Common first steps

After creating your connector repository, you may need to configure team access.

​
Adding team members

If you need to add team members to work on your connector, add them to the team_members section in self-service.tfvars: 
team_members = {
  "developer@example.com" = {
    github = {
      github_teams = ["development", "applications-live"]
    }
    grandcentral = {
      roles = ["dev-rw", "dev-ro"]
    }
  }
}

​
Understanding access levels

  • GitHub teams: Control repository access
    • development: Write access to development repositories
    • applications-live: Write access to applications-live repository
    • self-service: Can approve PRs in self-service repository
  • Grand Central roles: Control runtime access
    • dev-rw: Full access to dev runtime
    • dev-ro: Read-only access to dev runtime
    • Similar roles available for stg, test, and uat environments