OrgImpact

OrgImpact — Understand dependencies, predict impact, resolve incidents faster.

Comment

About the Project

Inspiration

As software applications grow, they become connected to many different services, databases, APIs, and infrastructure components. A small change in one part of a system can sometimes create unexpected problems in another part. When an incident occurs, developers may spend a lot of time trying to understand what is connected, what has failed, and which other components could be affected.

This inspired us to build OrgImpact, a platform that helps teams understand their system dependencies and assess the potential impact of incidents or technical changes. Instead of trying to trace every connection manually, we wanted to provide a clearer picture of how different components work together.

The main idea behind OrgImpact is simple: understanding dependencies makes it easier to understand impact. By bringing these relationships into one place, we aim to help engineering teams investigate problems faster, make more informed decisions, and manage complex systems with greater confidence.

What It Does

OrgImpact is a dependency and impact analysis platform that helps teams visualize the relationships between different parts of their technical environment.

The platform focuses on connecting components such as applications, services, databases, and infrastructure resources. These relationships help teams understand how a failure or change in one component could affect other connected components.

Key features include:

  • Dependency Mapping: Organizes connected services, databases, applications, and infrastructure components so teams can better understand their system structure.
  • Impact Analysis: Helps identify potentially affected components when an incident or change occurs.
  • Incident Tracking: Provides a place to record and track incidents, making it easier to understand issues in the context of system dependencies.
  • Multi-Tenant Architecture: Supports separating organizational data so that different organizations can manage their information independently.
  • Authentication and Access Control: Uses JWT-based authentication and role-based access control to support controlled access to platform features and organizational data.
  • Interactive User Interface: Provides a React and TypeScript interface for working with dependency information and understanding relationships between components.
  • Backend APIs: Uses REST APIs to manage authentication, organizations, entities, relationships, and incident-related information.

The goal is to make dependency information more accessible and useful, especially when teams need to investigate incidents or evaluate the possible consequences of a technical change.

How We Built It

We built OrgImpact using a modern full-stack architecture, with a focus on maintainability, data management, and secure handling of organizational information.

Frontend: We used React and TypeScript to build the user interface. The goal was to make the platform interactive and easier to work with while keeping the code organized and maintainable.

Backend: We used Node.js, Express.js, and TypeScript to develop the backend REST APIs. These APIs handle core application operations, including authentication, organization management, entity management, dependency relationships, and incident tracking.

Database: We used PostgreSQL to store structured application data and Prisma ORM to interact with the database. This helped organize the data model and manage relationships between different records.

Authentication and Access Control: We implemented JWT-based authentication and designed the application around organizational data isolation and role-based access control. These features are important for a platform intended to support multiple organizations.

Rate Limiting: We incorporated Redis for rate-limiting support to help control request frequency and strengthen API protection.

Real-Time Communication: We used Socket.IO as part of the technology stack to support real-time communication capabilities.

Deployment and Development Workflow: We used Docker and GitHub-based workflows to support a more consistent development and deployment process.

Throughout development, we focused on connecting the frontend, backend, and database into a single application that could represent system dependencies and support incident impact analysis.

Challenges We Ran Into

One of the main challenges was designing a useful way to represent relationships between different technical components. A dependency platform needs more than a list of services; it needs to organize their connections in a way that helps users understand how one component relates to another.

Another challenge was designing the data model. Organizations, components, dependency relationships, and incidents are connected in different ways, so we needed to structure the PostgreSQL database carefully and manage these relationships through Prisma ORM.

Multi-tenant data separation was another important consideration. Since different organizations may use the same platform, we needed to think carefully about how organizational data should be separated and how access should be controlled.

We also had to bring several technologies together. The React and TypeScript frontend needed to communicate reliably with the Node.js and Express backend, while authentication, database operations, rate limiting, and deployment workflows needed to work as parts of the same system.

These challenges helped us think beyond individual features and consider how the complete application should work as a connected product.

Accomplishments That We're Proud Of

We are proud to have developed OrgImpact as a full-stack project that addresses a practical engineering problem rather than simply demonstrating individual technologies.

Some of our key accomplishments include:

  • Building a full-stack application using React, TypeScript, Node.js, Express.js, and PostgreSQL.
  • Developing REST APIs for authentication, organizations, entities, dependency relationships, and incident tracking.
  • Designing a multi-tenant architecture with organizational data separation in mind.
  • Incorporating JWT authentication and role-based access control.
  • Integrating Prisma ORM for structured database operations and Redis for rate limiting.
  • Including Socket.IO in the technology stack for real-time communication capabilities.
  • Using Docker and GitHub-based workflows to support development and deployment.

Most importantly, we are proud of the idea behind the project: helping teams move from scattered information about their systems toward a clearer understanding of dependencies and potential impact.

What We Learned

Building OrgImpact helped us understand how different parts of a full-stack application fit together in practice.

We gained experience with designing REST APIs, structuring relational data in PostgreSQL, managing database interactions with Prisma ORM, and connecting a React and TypeScript frontend to a Node.js backend.

We also learned more about the importance of authentication, authorization, multi-tenant data separation, and API protection when building applications that may serve multiple organizations.

Beyond the technical side, the project taught us to think about software from the user's perspective. A feature is only useful if it helps solve a real problem. In OrgImpact, that meant focusing not just on storing dependency information, but on making those relationships meaningful when a team needs to understand the potential impact of a change or incident.

We also learned that building a maintainable application requires thoughtful decisions about architecture, data modeling, integration, and deployment from the beginning.

What's Next for OrgImpact

We see OrgImpact as a foundation that can grow into a more comprehensive dependency intelligence and incident impact analysis platform.

Our next steps would focus on making dependency discovery and impact analysis more automated and useful for engineering teams.

Some planned improvements include:

  • Visual Dependency Graphs: Improving how users explore connections between services, databases, applications, and infrastructure.
  • Automated Dependency Discovery: Exploring integrations that can discover dependencies from existing systems and reduce manual data entry.
  • Advanced Impact Analysis: Developing more sophisticated ways to trace dependency relationships and identify potentially affected components.
  • Cloud and DevOps Integrations: Exploring integrations with cloud environments, monitoring platforms, and deployment pipelines to keep dependency information more up to date.
  • Incident and Change Insights: Providing richer context around incidents and planned changes so teams can investigate issues and assess risks more efficiently.
  • Improved Collaboration: Exploring team comments, notifications, incident timelines, and shared investigation workflows.
  • Testing and Reliability: Expanding automated testing, improving observability, and strengthening the application's security and reliability as it evolves.

Our long-term vision is to help engineering teams understand not only what exists in their systems, but also how changes and failures can affect the wider environment.

OrgImpact aims to make complex system dependencies easier to understand, potential risks easier to identify, and incident investigation more informed. We want to keep building toward a platform that helps teams make better technical decisions before small problems turn into larger ones.

Share this project:

Updates

Submission history