Packaged Business Capabilities: How and Why

Leveraging Bit for Effective Implementation of PBCs

‘Package Business Capabilities’ (PBCs), a term coined by Gartner, are independently deployable and functionally discrete units of software that align with a business model, objectives, and language.

PBCs enable organizations to be more agile and responsive to change. Companies can easily adapt their IT systems by adding, updating, or replacing individual capabilities without impacting the rest of their operations. This facilitates innovation and allows businesses to respond quickly to new opportunities or threats.

PBCs are composed together by “fusion teams” to deliver innovative solutions. These teams are cross-functional groups inside an organization with expertise in various domains, such as IT, business units, finance, and operations.

Thanks to the simplicity and clarity that PBCs bring, fusion teams can collaborate more effectively, breaking down traditional silos and fostering a culture of open communication and shared responsibility.

This collaboration is facilitated by the PBC’s well-defined interfaces and encapsulated functionality, which allows team members from different backgrounds to understand and contribute to the project without needing to delve deeply into the technical details of other components.

Hosting PBC components on Bit Scopes

Scopes on the Bit Platform are often utilized as a sandbox for PBC teams, allowing them to create and manage their PBCs in isolation. This enables a focused approach to development and delivery.

Scopes on Bit Platform

A single scope on the Bit Platform contains the relevant components required to deliver a particular business capability.

A scope on Bit Platform hosting the Blog PBC component and its dependencies

‘Fusion teams’ can use scopes to search and explore the various PBCs available in an organization, compose their own solutions, and host them in their own scopes.

Since every Bit component has a clear interface and a clear purpose, Gartner’s goal of bringing business and technology closer together is realized in all levels of granularity. From granular components to whole business capabilities, Bit provides a comprehensive platform that encourages collaboration between technical and non-technical team members.

Building PBCs

‘Independently deployable and functionally discrete units of software’ sounds a lot like microservices, and indeed, PBCs share some similarities with the microservice architectural style. However, unlike microservices, which are small and often focused on a specific technical task, PBCs tend to encapsulate larger areas of functionality, corresponding to significant, self-contained business activities.

A PBC can be implemented using a microservice architecture and will most likely include a number of microservices that function together to fulfill its business purpose or process.

Regardless of how PBCs are implemented, the important thing is that they maintain autonomy. PBCs interact with other PBCs through well-defined APIs or messaging protocols, allowing flexibility and scalability.

For example, the following Bit component is composed of several microservices that provide a full “purchase” experience, including product selection, cart management, checkout processing, and payment integration. This component is of the type “platform,” which means it is composed of several services that are orchestrated and deployed as a single system, a single solution.

import { Platform } from '@bitdev/platforms.platform';
import { KubernetesDeployer } from '@backend/kubernetes.kubernetes-deployer';

const ProductCatalogService = import.meta.resolve('@acme/e-commerce.services.product-catalog');
const ShoppingCartService = import.meta.resolve('@acme/e-commerce.services.shopping-cart');
const CheckoutService = import.meta.resolve('@acme/e-commerce.services.checkout');
const PaymentService = import.meta.resolve('@acme/e-commerce.services.payment');

const ECommerceApiGateway = import.meta.resolve('@acme/e-commerce.api-gateway');

export const ECommercePbc = Platform.from({
  name: 'e-commerce-pbc',

  backends: {
    // the POC's entry point
    main: ECommerceApiGateway,
    services: [
      // compose micro-service components
      ProductCatalogService,
      ShoppingCartService,
      CheckoutService,
      PaymentService
    ]
  },
  deploy: KubernetesDeployer.deploy({...config})
});

export default ECommercePbc;

To learn more, see:

Composable Platforms | Bit

Composing PBCs to full solutions

A composition of any sort will only be as effective as the design, planning, and governance frameworks in place to ensure all PBCs work in harmony.

One such strategy would be to use standardized “aspect components” orchestrated into a single platform using “Harmony,” a dependency injection framework provided by Bit.

These aspects can implement a standardized API layer for POCs to abstract the underlying complexity and provide a consistent interface that can be consumed by various clients and services within the system.

For example, the following online fashion store is extended with content management capabilities by using the Blog PBC:

import { HarmonyPlatform } from '@bitdev/harmony.harmony-platform';
import { NodeJSRuntime } from '@bitdev/harmony.runtimes.nodejs-runtime';
import { BrowserRuntime } from '@bitdev/harmony.runtimes.browser-runtime';
import { SymphonyPlatformAspect } from '@bitdev/symphony.symphony-platform';
import { ApparelWavesPlatformAspect } from '@learnbit/apparel-waves.apparel-waves-platform';
import { BlogAspect } from '@learnbit/blog-pbc.blog';

/**
 * compose the apparel-waves platform.
 */
export const ApparelWaves = HarmonyPlatform.from({
  name: 'apparel-waves',
  platform: [
    SymphonyPlatformAspect,
    {
      name: 'Apparel Waves',
      slogan: 'Making waves in fashion',
      domain: 'apparel-waves.com',
    },
  ],

  runtimes: [new BrowserRuntime(), new NodeJSRuntime()],

  aspects: [
    ApparelWavesPlatformAspect,
    [
      BlogAspect,
      {
      // the Contentful space id that stores the content
        spaceId: 'xxxxx',
      },
    ],
  ],
});

export default ApparelWaves;e;

To learn more about PBC compositions using Bit’s Harmony platform, see:

Pluggable PBCs with Bit Harmony

Conclusion

PBCs serve as the building blocks for modern enterprise architecture, providing a structure that is inherently nimble and conducive to change. Organizations that embrace PBCs as a foundation for their IT strategy can expect to not only meet the current market demands but also be well-positioned to capitalize on future waves of innovation.

As the adoption of PBCs becomes more widespread, organizations that master their implementation and integration will find themselves at the forefront of their respective industries, ready to leverage technological progress to drive sustained growth and success.

It’s crucial for businesses to not only understand the value proposition of PBCs but also to invest in the right talent, processes, and tools that can make the most of this approach. By doing so, they will be able to foster a culture of continuous improvement and innovation, ensuring that IT and business objectives are not only in sync but also adaptable to the shifting landscapes of their industries.