Networking

REST APIs as a Standard

Our platform fully embraces REST APIs as a reliable and standardized way to communicate between web applications and backend services. Choosing REST ensures simplicity, consistency, and broad compatibility, allowing your teams to quickly integrate various services without unnecessary complexity.

By focusing exclusively on REST, our architecture remains straightforward, predictable, and easy to manage—minimizing technical overhead and simplifying maintenance.

Centralized API Definitions & Management

To maintain consistency and quality across all applications, we centrally manage all API definitions within our dedicated api-contracts repository. Every API change is systematically documented, validated, and tracked, significantly simplifying collaboration and API management across your organization.

• Centralized Repository: All APIs are documented and versioned in one place, making them easily accessible and transparent for your entire team.
• Quality Assurance with Spectral Lint: Every API definition undergoes automated validation using Spectral Lint, ensuring high-quality standards and eliminating common design issues.

Automated Client Generation

We automate the process of creating frontend clients from API definitions, significantly reducing manual integration work. This automation improves accuracy and consistency, accelerating development cycles and enabling frontend teams to quickly adapt to backend changes.

Key benefits of our automated client generation include:

• Instant Frontend Integration: Once backend developers publish API changes, new client libraries are automatically generated.
• Consistency & Accuracy: Generated TypeScript clients guarantee correct typings, reducing integration errors and development friction.
• Customized Code Generation: We utilize customized versions of the OpenAPI Code Generator tailored to meet frontend requirements, supporting popular libraries such as Axios and Fetch API.

These client libraries are automatically published to our internal package repository (Gitea), simplifying frontend integration.

Seamless Workflow (Code-first Approach)

Our backend teams prefer a straightforward code-first workflow, making development rapid and intuitive. Frontend integration requires minimal effort:

1. Backend Development: Backend teams implement new API features directly in code and push their changes.
2. Automated Pipelines: Upon pushing changes, automated CI pipelines immediately:
   • Validate API definitions using Spectral Lint.
   • Generate and publish new client libraries to our internal registry.
3. Frontend Update: Frontend teams simply update the relevant package:

   npm update @eit/api-client-users
   

Frontend teams seamlessly leverage the latest backend changes, eliminating delays, manual synchronization, and reducing errors.

Practical Example

Imagine your backend team adds new fields to a customer profile API:

• Backend developers implement and push their code changes.
• CI pipeline automatically validates the API and generates a new TypeScript client library, instantly publishing it as a package.

Frontend teams effortlessly update their projects with one command:

npm update @eit/api-client-customers

Immediately, they have full access to the new fields with complete, accurate typings:

import { CustomersApi } from '@eit/api-client-customers';

const api = new CustomersApi();

async function getCustomerProfile(customerId: string) {
  const profile = await api.getCustomerProfile({ id: customerId });
  console.log(profile); // instantly includes new fields from backend
}

This automated process streamlines collaboration between backend and frontend teams, accelerating feature delivery, ensuring accuracy, and significantly enhancing overall productivity.

Key Advantages for Your Organization:

• Simple, predictable REST-based architecture
• Centralized, quality-assured API documentation
• Automated client generation reducing development time
• Minimal effort required for frontend integration
• Rapid adoption of backend changes by frontend teams

By leveraging our structured approach to networking, your teams benefit from a reliable, efficient, and collaborative development process, ultimately delivering better applications faster.