In many organizations, application inventory data exists, but it is hard to turn into an accurate, navigable view of how technology supports the business. BizFirst was built to close that gap. It helps teams organize applications into Business Capabilities, Domains, and Sub-domains, track mapping coverage (including orphans), and use GenAI-driven assistance to produce diagrams and insights that are easier to share with stakeholders.
This post walks through what BizFirst is for, how it is used in practice, and the architecture and technology choices that make it work.
Purpose and value proposition
BizFirst is designed to help teams move from “a spreadsheet of applications” to “a living map” of how applications support the business. Instead of leaving capability mapping as a one-off exercise, the application provides a dashboard, mapping workflows, and reporting tools that make it easier to maintain coverage over time and spot gaps quickly.
In practice, BizFirst focuses on a few core outcomes. It centralizes a structured capability hierarchy, supports bulk import and iterative mapping, highlights unmapped (orphan) applications, and provides reporting and export so teams can use the data downstream. It also includes GenAI-enabled functionality to generate diagrams and insights from the mapped data, which helps communicate the state of the landscape more effectively.
How it can be used
BizFirst supports multiple day-to-day user workflows that map closely to the way organizations run capability mapping and application rationalization efforts.
Business architecture and transformation teams can use the capability hierarchy screens to create and maintain the Business Capability → Domain → Sub-domain structure. They can then review how applications are distributed across that hierarchy and use the dashboard counts as a quick “health check” for mapping coverage.
Application portfolio and IT operations teams can upload an inventory file (CSV/Excel) and immediately see which applications are mapped and which ones remain orphans. From there, they can correct mappings, add missing records, and re-run mapping actions to keep inventory aligned with the capability model.
Leadership and stakeholders can use the reports to understand mapping completeness and coverage patterns, filter data by dimension (such as domain, sub-domain, or E2E business process), and export the resulting dataset for presentations or further analysis.
Finally, users can leverage the built-in AI chat experience for GenAI-driven outputs, including insights and diagram generation, which is particularly useful when a visual representation is needed for workshops or decision reviews.
Technique: how BizFirst is built
BizFirst is implemented as a multi-container application with a React frontend, a Node.js/Express backend, and a Python-based GenAI microservice. In the current implementation, the full application is deployed on AWS, with services running as containers and integrated with AWS-native identity, storage, and GenAI capabilities.
The components are designed so that the web application stays responsive and the GenAI workloads remain isolated in a dedicated service.
Frontend: React (dashboard, mapping, reporting, and AI chat)
The BizFirst user interface is a React single-page application. It provides the primary user workflows: viewing mapping counts on a dashboard, importing inventory files and managing mapped vs orphan applications, and exploring report views with filtering and export.
The application uses React Router for routing, Material UI and Ant Design components for UI, and TanStack React Query for data fetching and caching patterns. Authentication is handled by storing a token client-side and attaching it to API requests.
Key user-facing pages reflected in the code include:
- A dashboard view that fetches mapping counts, such as total capabilities/domains/sub-domains/applications, mapped applications, and orphan applications.
- An inventory upload and mapping experience with two primary tabs (“Mapping” and “Orphan”), including file upload with a sample template download flow, plus re-map and add-new actions.
- A reporting experience with filter-by and drill-down patterns, plus export functionality and an embedded AI chat modal.
Backend: Node.js + Express + TypeScript (APIs, data access, authentication, and S3)
The BizFirst backend is an Express application written in TypeScript. It exposes REST APIs under /api and authentication endpoints under /api/auth. It is responsible for the business logic around capability mapping, dashboards, reporting, templates, and orchestration of calls to the GenAI microservice.
The backend integrates with:
- A MySQL database via TypeORM for persistence and querying of mapping data and related entities.
- AWS Cognito for authentication, including verification of JWTs using the Cognito JWKS endpoint and refresh token support.
- AWS S3 for uploads and for report export artifacts (such as generated CSVs), including pre-signed URL generation.
From an architectural point of view, the backend follows a common routing pattern where Express routes map to controllers, which then use service-layer classes for database operations, reporting, file handling, and integrations.
GenAI microservice: Python + Flask + AWS Bedrock (insights and diagram generation)
BizFirst’s GenAI functions are implemented in a separate Python microservice using Flask. This service provides REST endpoints to process user input, generate analytical insights, and generate diagrams.
GenAI model access is provided via AWS Bedrock. In practice, the microservice is configured with Bedrock model identifiers and providers via environment variables and uses Bedrock-backed chat/LLM clients through its LangChain integration. This keeps GenAI calls within the AWS ecosystem and makes it possible to switch between supported foundation models without changing the overall BizFirst workflow.
At a high level, the microservice supports:
- Processing user input into either “retrieval” (data/table output) or “conversation” responses, with optional conversation history persistence.
- Generating insights (for example, charts) from retrieved data and returning them as base64-encoded images.
- Generating diagrams (including a standard business capability hierarchy diagram and an E2E business process diagram), with streaming responses suitable for long-running generation.
The service includes dependencies commonly used for data manipulation and visualization, such as pandas, matplotlib, seaborn, and graphviz, alongside AWS and Bedrock integration libraries used to run the GenAI prompts.
High-level architecture: how the pieces fit together
At runtime, the flow is straightforward:
- A user interacts with the BizFirst React web application to view dashboards, upload inventory files, or run reports.
- The frontend calls the Node/Express backend over HTTP, attaching an Authorization header for protected endpoints.
- The backend uses TypeORM to query and update MySQL data, and it uses AWS services (Cognito and S3) for identity and file/report handling.
- When GenAI outputs are needed (insights, standard diagrams, or E2E diagrams), the backend exposes GenAI endpoints and orchestrates calls into the Python microservice. The Python service runs its GenAI prompts against AWS Bedrock and returns results (including streamed image chunks).
The separation between the backend and GenAI microservice is intentional. It keeps AI/diagram workloads isolated, allows independent scaling, and avoids coupling the web API responsiveness to the performance characteristics of long-running generation tasks.
Deployment: running BizFirst on AWS
BizFirst is deployed on AWS as a containerized application. The backend API and the GenAI microservice run as containers within the same ECS task definition (compatible with AWS Fargate), with container images stored in Amazon ECR and logs written via the awslogs driver.
This deployment model fits the way BizFirst is used: the web/API tier remains stable and responsive for day-to-day mapping and reporting, while the GenAI tier can be operated and scaled independently as usage grows.
Conclusion
BizFirst brings structure, visibility, and speed to Business Capability Mapping. It combines a practical mapping workflow (dashboard, imports, mapping tabs, and reports) with GenAI-assisted outputs (insights and diagrams) so teams can both manage the data and communicate it effectively.
By using React for an accessible frontend, Node.js/Express with TypeScript and TypeORM for a robust API layer, AWS Cognito and S3 for secure identity and artifact handling, AWS ECS/Fargate for containerized deployment, and a Python Flask microservice powered by AWS Bedrock for GenAI workloads, BizFirst delivers a balanced architecture that supports both everyday operations and higher-value analytical outputs.