Asset Kinds

The T-matic platform is a powerful and versatile system for managing complex software ecosystems. At its core, T-matic introduces several key "kinds" or entity types, each serving a unique role in the software development lifecycle. These kinds enable organizations to model, develop, deploy, and manage their software components and resources effectively.

In this documentation, we will explore these essential kinds and their functionalities within the T-matic platform. From Components to APIs, Resources to Applications, and Artifacts to Systems, you will gain a comprehensive understanding of how these entities work together to streamline your software development processes.

Whether you're a developer looking to create and manage software components, an architect orchestrating the deployment of applications, or a system administrator optimizing resource utilization, this documentation will provide the insights and guidance you need to harness the full potential of the T-matic platform.

Let's dive in and explore the diverse set of kinds available within the T-matic platform, empowering you to build, deploy, and manage software solutions with precision and efficiency.

Core Entities

Code Components

A code component represents an individual piece of software, which can encompass a wide range of entities such as mobile features, websites, backend services, or data pipelines. These components can either be tracked within source control or utilize existing open source or commercial software solutions.

Coded components can implement APIs that allow other components to interact with them. They may also consume APIs implemented by other components or have direct dependencies on other components or resources during runtime.

APIs

APIs play a pivotal role in enabling large software ecosystems to scale effectively. In the T-matic platform, APIs are considered first-class citizens and serve as the primary means to discover existing functionality within the ecosystem. Components are responsible for implementing APIs, and APIs delineate boundaries between components.

APIs can be defined using various methods, such as RPC IDL (e.g., Protobuf, GraphQL), data schemas (e.g., Avro, TFRecord), or code interfaces. Regardless of the method, APIs exposed by components must be in a known machine-readable format to facilitate further tooling and analysis.

APIs have different levels of visibility, categorized as public (available for any component to consume), restricted (accessible to an allowlisted set of consumers), or private (only accessible within their system). Given that public APIs are a primary mode of interaction between components, the T-matic platform supports documenting, indexing, and searching all APIs for developers' ease of use.

Resources

Resources represent the infrastructure necessary for a component to operate during runtime. These can include various elements such as databases (e.g., BigTable), messaging systems (e.g., Pub/Sub), cloud storage (e.g., S3 buckets), or content delivery networks (CDNs). Integrating resource modeling with components and systems enables better visualization of resource footprints and the creation of supporting tooling.

Application

An application is a crucial entity within the T-matic platform and represents the runtime execution of a software component. It can be thought of as a running instance of a component, where the code and logic encapsulated by the component are actively used to fulfill specific tasks or functions.

Applications are dynamic and can be deployed on a set of resources, which may include hardware, virtual machines, containers, databases, and other infrastructure elements. These resources provide the necessary environment for the application to function as intended.

Applications play a vital role in the software ecosystem, as they represent the tangible outcomes of the development process. They are often associated with specific use cases, functionalities, or services provided to end-users or other system components.

Applications can interact with other components, consume APIs, and rely on resources to perform their designated functions. The T-matic platform allows organizations to manage, monitor, and optimize their applications effectively, providing insights into their performance and resource utilization.

Artifact

Artifacts are pivotal entities within the T-matic platform, serving as deployment-ready packages of code and resources that are essential for creating and running applications. These packages encapsulate all the necessary components, configurations, and dependencies required to ensure a smooth deployment and execution process.

Artifacts can encompass various forms of software packages or Docker images, making them versatile and adaptable to different deployment scenarios. They are typically derived from code components, either through manual configurations or automated processes, such as code generation using the T-matic Code Generator.

Once created, artifacts can be pushed to external storage locations, such as AWS S3, GitHub repositories, or Docker Registries, making them accessible for deployment and distribution to various environments.

The T-matic platform provides robust capabilities for managing and publishing artifacts, enabling organizations to streamline their software deployment processes and ensure consistency in application deployments across different stages of the software development lifecycle.

By incorporating applications and artifacts into the core entities of the T-matic platform, organizations gain a comprehensive view of their software ecosystem, from development and deployment to runtime execution, enhancing their ability to effectively manage and optimize their software assets.

Organizational Entities

User

A user represents an individual, such as an employee, contractor, or any person associated with the organization.

Group

A group describes an organizational entity, which can be a team, a business unit, or a loosely affiliated collection of individuals with shared interests.

System Modeling

Systems

Systems are collections of entities that collaborate to perform specific functions within your software ecosystem.

Domains

Domains help relate entities and systems to specific segments of your organization's business operations. Domains are particularly useful for grouping related systems, which share terminology, domain models, metrics, KPIs, business purposes, or documentation.

For example, systems within the "Payments" domain might provide documentation on accepting payments for new products or use-cases, share common entity types in their APIs, and seamlessly integrate with each other. Other examples of domains include "Content Ingestion," "Ads," or "Search."

Other Elements

Location

Locations serve as markers referencing various sources for catalog data, providing a means to access essential information distributed across different places.

Type

The "type" field within the system entity is flexible, allowing users to assign custom meanings to it. It can be utilized for link validation, custom UI components, or any other purpose tailored to your specific needs. Some common predefined types are depicted in the ecosystem modeling diagram.

Template

Template definitions encompass both the parameters rendered in the frontend part of the scaffolding wizard and the steps executed when scaffolding a component. Templates facilitate consistent and efficient software development processes.