Core Systems

Core Systems give you one central place to define the external services your platform connects to. Instead of copying connection strings and API keys into every integration, you define them once.

What are Core Systems?#

Core Systems act as a shared registry of external systems for your integrations. They let you:

• Define external systems once and reuse them anywhere
• Keep connection details out of individual scripts and flows
• Group systems logically (such as CRM, Database, or Payment Gateway)
• Share system definitions safely across teams

Key features#

• Centralized configuration: Update a database password in one place, and every integration using that system gets the update.
• Reusability: Reference the same system across multiple integrations, automations, and flows.
• Categorization: Organize systems by business category or technical type.
• Security: Store credentials securely by referencing Variables instead of hardcoding passwords.

System properties#

When you define a Core System, you provide:

Identification

• Name: The unique identifier used in YAML references
• Title: The human-readable display name
• Description: What the system does

Classification

• Category: The business function (CRM, ERP, Payment)
• Type: The technical protocol (Database, API, FileSystem)

Configuration

• Connection properties, authentication details, endpoint URLs, and API versions.

Creating Core Systems#

Via the UI#

1. Navigate to Core Systems.
2. Click Add… to create a new system.
3. Fill in the identification details (Name, Category, Type).
4. Configure the system-specific connection properties.
5. Save the system.

Via configuration#

apiVersion: weik.io/v1alpha1
kind: CoreSystem
metadata:
  name: production-database
spec:
  category: database
  type: postgresql
  title: Production PostgreSQL Database
  description: Main production database for customer data

  properties:
    host: "{{sys:PROD_DB_HOST}}"
    port: 5432
    database: customers
    username: "{{sys:PROD_DB_USER}}"
    password: "{{sys:PROD_DB_PASSWORD}}"
    sslMode: require

System categories#

Organize systems by their business function so they are easy to find later:

Integration systems

• CRM (Salesforce, HubSpot)
• ERP (SAP, Oracle)
• Marketing (Mailchimp, SendGrid)

Infrastructure systems

• Databases (PostgreSQL, MongoDB, SQL Server)
• Message queues (NATS, Kafka, RabbitMQ)
• Cloud storage (S3, Azure Blob, GCS)

Business systems

• Payment gateways (Stripe, PayPal)
• Identity providers (Auth0, Okta)

System types#

The technical type determines which configuration fields are required.

API systems

type: rest-api
properties:
  baseUrl: "https://api.example.com"
  apiVersion: "v2"
  authType: "oauth2"
  tokenEndpoint: "https://auth.example.com/token"

Database systems

type: postgresql
properties:
  host: "db.example.com"
  port: 5432
  database: "myapp"
  sslMode: "require"

File systems

type: sftp
properties:
  host: "sftp.example.com"
  port: 22
  basePath: "/data"

Message systems

type: nats
properties:
  servers: "nats://nats.example.com:4222"
  cluster: "production"

Using Core Systems#

In Integration Flows#

When writing an Integration Flow, you can reference the system directly:

apiVersion: weik.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: customer-sync
spec:
  source:
    coreSystem: production-database
    table: customers

  destination:
    coreSystem: salesforce-crm
    object: Contact

In automation#

If you write custom C# actions, you can retrieve the system configuration at runtime:

public async Task<ActionResult> Execute(ActionContext context)
{
    // Get the core system
    var dbSystem = await coreSystemsService.GetAsync("production-database");

    // Extract the connection string (assuming it's constructed or stored in properties)
    var connectionString = dbSystem.GetProperty("connectionString");

    using var connection = new NpgsqlConnection(connectionString);
    // ... use connection
}

In Data APIs#

You can also use a Core System as the backing source for a generated REST API:

apiVersion: weik.io/v1alpha1
kind: DataAPI
metadata:
  name: customers-api
spec:
  route: /api/customers
  coreSystem: production-database
  table: customers

Browsing systems#

The Browse… feature in the UI lets you discover templates, import common system definitions, and find connectors for popular third-party services.

Security best practices#

Use Variables for secrets Never hardcode passwords or API keys in your Core System YAML. Always use variables.

properties:
  apiKey: "{{sys:SYSTEM_API_KEY}}"
  password: "{{sys:SYSTEM_PASSWORD}}"
  connectionString: "{{sys:SYSTEM_CONNECTION}}"

Limit access Ensure only authorized team members can view or modify production Core Systems.

System validation Some system types support validation blocks to automatically test connections and verify credentials.

apiVersion: weik.io/v1alpha1
kind: CoreSystem
metadata:
  name: api-system
spec:
  type: rest-api
  properties:
    baseUrl: "https://api.example.com"
  validation:
    type: http
    endpoint: "/health"
    expectedStatus: 200

Practical examples#

Multi-environment configuration#

Define separate systems for different environments, keeping the naming convention consistent:

# Development
apiVersion: weik.io/v1alpha1
kind: CoreSystem
metadata:
  name: customer-db-dev
spec:
  category: database
  type: postgresql
  properties:
    host: "dev-db.internal"
    database: customers_dev

# Production
apiVersion: weik.io/v1alpha1
kind: CoreSystem
metadata:
  name: customer-db-prod
spec:
  category: database
  type: postgresql
  properties:
    host: "{{sys:PROD_DB_HOST}}"
    database: customers

External service integration#

apiVersion: weik.io/v1alpha1
kind: CoreSystem
metadata:
  name: salesforce
spec:
  category: crm
  type: rest-api
  title: Salesforce Production
  description: Main Salesforce org for customer data
  properties:
    instanceUrl: "https://company.my.salesforce.com"
    apiVersion: "v58.0"
    clientId: "{{sys:SFDC_CLIENT_ID}}"
    clientSecret: "{{sys:SFDC_CLIENT_SECRET}}"
    username: "{{sys:SFDC_USERNAME}}"
    password: "{{sys:SFDC_PASSWORD}}"

System templates#

You can define CoreSystemTemplate resources to standardize how certain systems are configured across your organization. For example, you can enforce that every PostgreSQL connection must provide a database and password.

apiVersion: weik.io/v1alpha1
kind: CoreSystemTemplate
metadata:
  name: postgresql-template
spec:
  type: postgresql
  properties:
    - name: host
      type: string
      required: true
    - name: port
      type: integer
      default: 5432
    - name: database
      type: string
      required: true
    - name: username
      type: string
      required: true
    - name: password
      type: string
      required: true
      secret: true
    - name: sslMode
      type: string
      default: prefer
      values: [disable, allow, prefer, require]

Next steps#

• Integration Overview: Use these systems in your data flows
• Data APIs: Expose system data securely via APIs
• Using Variables: Learn how to safely store system credentials