An overview of the platform Architecture

Modified on Mon, 3 Feb at 6:15 AM

Cubyts is a cloud intelligence platform for real time SDLC-drift resolution, powered by state of the art Gen AI models on Google Vertex AI. The core architecture of the Cubyts platform is driven by four key engines, which serve as the nerve center of the entire platform.

Data pipeline (Connectors & Extractors) and Context aware data lake:

The Data pipeline governs the integration with the Systems of records in an enterprise landscape, extracts data from the systems of records using APIs and fuels the data with context and stores the same in the context aware data lake.

The platform supports integrations with the following categories of tools:

Project management tools e.g. Jira where the software backlog, execution plan (current and future) are present.
Product definition tools e.g. Figma, Confluence, (Google, MSFT) documents where the job is described as functional specification, UI/UX specification, technology specification , etc.
Version control systems e.g. Github, Gitlab, Bitbucket where the code is present.
QA tools e.g. XRay, etc, where the test plan, test results, etc. are present.
CI/CD tools e.g. Jenkins, Github actions, AWS Code deploy, etc. that take care of building the codebase and deploying the codebase in various environments.
Feedback tools e.g. qualitative feedback tools (JSM, Freshdesk, etc.) or quantitative (analytics) tools (Mixpanel, Amplitude, etc.) that capture customer feedback.

By connecting to these tools, the platform gets the much needed powerful context for any analysis (e.g. the platform knows the origin of any code in a PR and the downstream journey of the PR).

The ROI of Cubyts can be fully extracted by connecting with just two category of tools i.e. a tool like Jira and a tool like Github

Once the context powered data is available in the data lake, the engines (mentioned below) pick them up to discover drifts.

Drift discovery engines:

Deterministic engine

The deterministic engine leverages the data points exposed by the systems of records, processes them using (Cubyts) proprietary algorithms to discover drifts. A sample use case is outlined below:

Assessment of quality of design handoffs from the definition team to engineering:

The platform extracts all the (Figma) sections handed off to the engineering team from Jira issues (in an active sprint).
It processes the design components, naming conventions, collaboration intensity, etc. vis-a-vis rules/standards established in the design system, established based on standard Figma guidelines, etc. to determine the quality of the handed-off section.
If the quality of the section is below the threshold set in the platform then it flags the workspace members about the situation.
Impact of this flag: With this knowledge, the engineering team working on the designs
(with the lead) can take a call on whether it's worthwhile to continue the development efforts (as the spec. may change) or leave it for a future sprint.

Pattern engine

The pattern engine uses good old fashioned AI with vectorization to determine drifts based on patterns. A sample use case is outlined below:

Assessment of quality of engineering planning based on established enterprise benchmarks:

The platform provides mechanisms to configure enterprise benchmark documents e.g. Best practices to write backend APIs, Best practices to build react components, Best practices to author factory/workflow pattern using Javascript technology, etc.
Once configured, the platform automatically extracts development work (represented in a story) from an active sprint and compares it against the most appropriate benchmark document(s).
The platform applies principles of vectorization to determine the planning gaps and helps the engineer on the job to plan better by offering recommendations on important technical items that must be considered during the build process.
Impact of this flag: With this knowledge, the engineer working on the story has comprehensive visibility of various functional and technical considerations that must be kept in mind to complete the job on hand (to ensure completeness of code).

Prediction engine

The prediction engine is a comprehensive RAG architecture with inbuilt LLM/SLM aggregations, pattern engine processes various artefacts to determine the drifts (based on user/platform defined conditions), assesses the impact of the drift (if not fixed) and provides a resolution path. A sample use case is outlined below:

Assessment of quality of code based on established standards e.g. performance standards:

The platform provides mechanisms to establish origanization programming/coding standards e.g. the team wants to ensure that the backend codebase written by a backend engineer is performance ready (based on multiple considerations).
Once configured, the platform automatically extracts the code changes introduced in a Pull Request/Merge Request/Feature branch, assesses the quality of code vis-a-vis the provided conditions and discovers all the drifts in the codebase.
Impact of this flag: This is a powerful workflow as events like performance analysis is taken up (usually) at the end of sprint or end of couple of sprints. With this proactive knowledge of all the code drifts (as the code is being written), the engineer can fix all the issues as the job is being done rather than waiting for surprises at the end of a couple of sprints to fix issues.

Drift composition engine:

The drifts discovered by the engines (mentioned above) are compiled with the context by the composition engine and sent to the assistants for consumption.

Assistants for consumption:

Cubyts offers 4 assistants to aid the consumption (and therefore correction) of the discovered drifts:

Flags is the drift assistant for the scrum team; flags discover 4 types of drifts in the system:

Process drift: Deviation from established processes causing Missed deadlines, Wasted effort, and Reduced team efficiency.
Code drift: Technology and code quality drifts resulting in Increased debugging time, Delayed delivery, and Higher technical debt.
Compliance drift: Missed adherence to info sec, regulatory standards resulting in audit risks.
Feature drift (coming soon): Deviation from PRDs, User stories, Feedback resulting in Unplanned work, Delayed launches & Unrealized customer expectations.

Trace is the data assistant for Scrum teams, the trace functionality offers the following assistance to the scrum team:

Automatic trace of the journey of code from inception to adoption with several augmented data points for analyzing the impediments in the journey.
Automatic mashup of critical data points (and it's relationship with flags) from an artifact or team member standpoint; useful for analyzing contributions, risks, workload, productivity, efficiency of execution and members (who are executing the outcomes).
Automatic visibility into the artifacts that deviations from the established compliance standards (configured in flags).

Repository is the knowledge assistant for Scrum teams, the repository functionality offers the following assistance to the scrum team:

Aggregates all the documents linked in the various systems of records.
Provides context to all the documents (e.g. all the document references in a story or a task).
Discovers all the related documents in the same context.
(In the future) Offers a quick summary of any document picked up by the user.

Ask Nebula (coming soon) is the Conversation assistant for Scrum teams, offers the following assistance to the scrum team:

Enables easy discovery of drifts and trace data points using a natural and intuitive conversational experience.
Enables reasoning based conversation with the system to discover the impact of drifts.

Conclusion

The intelligent, scalable and flexible Cubyts platform (powered by Google vertex AI) acts as your silent AI assistant for proactive SDLC governance that reviews and fixes process, feature, code and compliance/regulatory drifts. Enjoy reduced tech-debt, faster delivery, higher productivity, and stronger alignment with business goals.