Blog https://gorgona.uz ru Mon, 04 May 2026 18:02:18 +0300 How We Tamed AI for HR and Started Generating Individual Development Plans in Minutes https://gorgona.uz/en/blog/ai-performance-review https://gorgona.uz/en/blog/ai-performance-review?amp=true Mon, 04 May 2026 17:48:00 +0300 Case studies Learn how AI automates Individual Development Plans (IDPs), reducing time, improving personalization, and boosting employee retention.

How We Tamed AI for HR and Started Generating Individual Development Plans in Minutes

In IT teams, Individual Development Plans (IDPs) often look like a formality - until you actually have to create them. On paper, the process seems straightforward: collect feedback, assess skills, define goals. In reality, it turns into a time-consuming task of consolidating fragmented inputs into a coherent, non-generic development plan.
In this case study, we explain how we automated IDP creation and trained a system to generate personalized development plans in minutes based on HR data and performance evaluation results.

The Previous State

The HR department regularly conducts performance reviews - a comprehensive employee assessment process that includes feedback collection, skill evaluation, and tracking development over time.
This process gathers input from peers, clients, and team leads, while evaluating both hard and soft skills. Based on this data, an IDP - an Individual Development Plan - is created to outline growth areas and improvement priorities.
The main bottleneck appeared at the IDP creation stage.
Previously, team leads compiled these plans manually. Each IDP took 30-40 minutes, and even longer with extensive feedback. Every time, they had to restructure scattered notes into a coherent plan, often facing the “blank page” problem - when everything is clear conceptually, but difficult to articulate quickly into a structured document.

How AI Changed the Process

The turning point came when we seriously explored generative AI. We avoided simplistic approaches like “generate a development plan for a mid-level developer.” It became clear that generic prompts wouldn’t deliver meaningful results.
Instead, we leveraged the company’s internal data assets: feedback, performance reviews, and employee development history. This became the foundation of the solution and its key competitive advantage.

Inside the System: How IDPs Are Generated

We built an AI-powered tool that automatically generates Individual Development Plans based on hard and soft skill assessments from performance reviews. Each plan is tailored to the employee and focuses on specific growth areas rather than generic templates.

How it works

Each employee accumulates a structured history over time: evaluation results, peer feedback, leadership notes, and previous development plans. This data is consolidated into a unified context, which the system transforms into a master prompt - a comprehensive input hidden from the end user.
The user flow is intentionally simple: select an employee and click “Generate IDP.”

Behind the scenes, the system:

  • Retrieves employee data, including hard and soft skill assessments
  • Aggregates it into a structured context
  • Builds a master prompt focused on strengths, growth areas, and team context
  • Sends it to the model for generation
  • Produces multiple IDP variations
  • Saves the result in an editable format for further refinement by the team lead
In essence, the system handles data aggregation, structuring, and the initial draft. At the same time, the output remains fully controllable: managers can refine wording, add comments, and finalize the plan before sharing it with the employee.

Business Impact

The implementation of the IDP generator significantly improved how development plans are created - making the process faster, more consistent, and more personalized without sacrificing expert control.

Results:

  • Time spent on IDP creation reduced from 4-6 hours to 15 minutes
  • IDP completion rate increased from 65% to 90%
  • Employee turnover decreased by 15%
  • The “blank page” problem was eliminated
  • Plans became more personalized благодаря учету полной истории развития сотрудника
  • Flexibility was preserved - IDPs can be edited and adapted to real-world needs
Overall, the process shifted from manual document creation to a model where AI handles data processing and initial structuring, while humans focus on content quality and final decision-making.
]]> Unified AI Platform for Citizen Requests: From Fragmented Tickets to a Single Workflow https://gorgona.uz/en/blog/omnichannel-ai-support https://gorgona.uz/en/blog/omnichannel-ai-support?amp=true Mon, 04 May 2026 17:53:00 +0300 Case studies AI platform centralizes citizen requests, reduces processing time, and automates responses with RAG and sentiment analysis.

Unified AI Platform for Citizen Requests: From Fragmented Tickets to a Single Workflow

City services process a continuous stream of citizen requests every day, coming from dozens of channels - public portals, chatbots, social media, and written submissions. A significant portion of these requests are repetitive or require standard responses, yet they are still handled manually.
We developed an AI-powered platform for a large metropolitan municipality that consolidates all incoming requests into a single system and accelerates processing through a knowledge base and sentiment analysis.

The Challenge

During request processing, recurring patterns consistently exposed weaknesses in the system.
For example, the same incident - such as a fallen tree in a courtyard or uncleared snow - could be reported simultaneously via the city portal, chatbot, and social media. As a result, it would be registered multiple times and routed to different departments, where it would be processed in parallel.
Another common scenario: a user submits a request through an “official” channel and then duplicates it via another service, unaware that it is already being handled. The system could not correlate these cases, so they continued to exist as separate tickets.
There was also the opposite issue: operators often received requests without full context. To understand the situation, they had to manually check multiple systems and coordinate with other departments.
Additionally, the system was overloaded with standard inquiries such as:
  • where to report housing and utilities issues
  • how to submit a request
  • expected processing timelines
These consumed operator time despite being easily resolved with predefined responses.
Ultimately, the problem was not the volume of requests itself, but the system’s inability to consolidate, classify, and respond efficiently where answers were already known.

From Fragmented Requests to a Unified Flow

We designed a system that aggregates and standardizes request processing across all channels into a single operational framework.
The core idea is that requests no longer exist in isolated tools or departmental systems. Instead, all incoming data is centralized in one platform, regardless of its source - city portal, chatbot, social media, or internal services.
The platform acts as a unified processing hub: it ingests requests, normalizes them, and distributes them based on predefined responsibility logic.

How the System Works

A user submits a request through any available channel - portal, chatbot, social media, or internal system. The platform then converts it into a structured request within a unified data model.
All incoming requests pass through a single entry point, where they undergo initial processing and classification. At this stage, the system determines the topic and automatically routes the request to the appropriate domain:
  • urban infrastructure (roads, maintenance)
  • housing and коммунальные services (housing & utilities)
  • emergency incidents
  • other categories
Once routed, the request is assigned to the responsible department and processed through an end-to-end workflow: intake → assignment → resolution → response.
A transparent status model is maintained at every stage, showing exactly where the request stands and what actions are being taken. This eliminates lost tickets and reduces uncertainty for all stakeholders.

Where AI Adds Value

Sentiment Analysis for Request Understanding

The first layer is sentiment analysis.
Each incoming message is automatically analyzed to determine both emotional and operational context:
  • neutral request
  • negative or conflict-driven message
  • potentially urgent situation
This allows operators to instantly assess the nature of the request, while enabling the system to prioritize processing accordingly. In practice, it serves as an early signal of urgency and required response mode.

RAG-Based Knowledge Layer for Fast Responses

The second layer is an intelligent knowledge base built on a Retrieval-Augmented Generation (RAG) approach.
When the system or an operator encounters a standard query, the platform retrieves relevant articles, instructions, or policy-based responses.
This is applied in scenarios where:
  • a standardized answer already exists
  • no involvement from a specialized department is required
  • the request can be resolved quickly without additional routing
In essence, RAG reduces manual information lookup and significantly speeds up handling of repetitive requests.

Outcomes

The platform significantly transformed request processing - from a manual, fragmented workflow to a centralized and predictable system.
Key results:
  • 23% of requests are now resolved automatically using standard responses powered by the RAG knowledge base
  • Average processing time reduced from 4 hours to 25 minutes due to automated routing and fewer manual operations
  • 15% of requests identified as duplicates, enabling automatic merging and reducing workload
Overall, the system not only accelerated request handling but also reduced operational redundancy by eliminating duplicate work and balancing load between automation and human operators.
]]> From Interview to Report in Minutes: AI for Candidate Assessment https://gorgona.uz/en/blog/automate-hr-reports https://gorgona.uz/en/blog/automate-hr-reports?amp=true Mon, 04 May 2026 17:57:00 +0300 Case studies AI automates interview analysis and report creation, helping HR teams generate structured competency-based assessments faster and more accurately.

From Interview to Report in Minutes: AI for Candidate Assessment

An hour-long interview - followed by several more hours to prepare a report. Traditionally, this meant extensive manual work: refining wording, aligning expert opinions, and consolidating final conclusions.
Today, AI handles the initial processing and structuring, allowing experts to focus on analysis and decision-making.
In this case study, we explain how we built a service in just three weeks that automatically processes interviews, maps responses to competencies, and accelerates the creation of expert reports.

Why This Solution Was Needed

In talent assessment workflows, interviews are only the starting point. The real workload begins afterward: experts analyze candidate responses, map them to competencies, and produce final reports to support hiring decisions.
For the client, this process was heavily manual. Each report took an average of 2–3 days and involved expert discussions, documenting observations, filling templates, and multiple approval cycles. Even with a standardized structure, every report had to be built from scratch for each candidate.
Over time, it became clear that most effort was spent not on analysis itself, but on formatting and repetitive tasks. This is where the core objective emerged - accelerate report preparation without compromising the quality of expert evaluation.

Key Requirements

Through discussions with the client, it became clear that the goal was not just speed. Experts rely on their judgment and experience, so the system had to augment - not replace - human expertise.
  • Automate routine report preparation tasks so experts can focus on analysis
  • Structure interviews and analyze responses without losing important details
  • Highlight overlooked insights and identify strengths and weaknesses across competencies
  • Provide recommendations and supporting arguments to inform expert decisions

Augmenting, Not Replacing Experts

The core principle behind the solution was simple: speed up report creation while preserving analytical quality. The goal was not to offload the entire process to AI, but to eliminate routine tasks and provide experts with a structured foundation for analysis.
In this workflow, AI acts as an assistant. It handles data processing, structuring, and initial interpretation, while the expert reviews, refines, and makes final decisions.
The result is a service built on our platform that transforms interview recordings into structured competency-based assessments.

How the Process Works

  1. The expert uploads the interview audio and selects competencies for analysis
  2. The system transcribes the recording and segments it into meaningful parts
  3. AI maps responses to competencies and generates an initial assessment
  4. The output is a structured report with arguments and identified strengths and weaknesses
The entire workflow is handled within a single interface. Users can review transcripts, run analysis, switch between competencies, and edit the final report. Competency models are fully configurable and can be adapted to different assessment methodologies without changing system logic.
An AI-powered chat is also integrated as a refinement tool. Experts can clarify interview segments, rephrase conclusions, and explore alternative interpretations.
Data processing is implemented with security in mind: interviews are anonymized before analysis and are not transmitted to external services.
As a result, experts receive not raw data or empty templates, but a structured draft report that can quickly be finalized.

Results

The system delivered two key outcomes: faster report generation and an additional analytical layer that improves both speed and accuracy.
  • “Second opinion” in minutes - experts receive a structured AI-generated assessment within 5–7 minutes and use it as a foundation instead of building reports from scratch
  • Reduced routine workload - a significant portion of time previously spent on formatting and wording is now automated
  • Flexible configuration - competencies can be added and customized for different methodologies without changing system logic
  • AI chat as a working tool - used to refine conclusions, improve wording, and generate development recommendations that are directly included in the final report
As a result, experts can focus on the substance of evaluation, while reporting becomes a natural extension of the analysis process rather than a separate, time-consuming task.
]]> When GenAI Steps In: Generating Test Cases and Automated Tests https://gorgona.uz/en/blog/aqa-ai-service https://gorgona.uz/en/blog/aqa-ai-service?amp=true Mon, 04 May 2026 18:00:00 +0300 Case studies Discover how generative AI automates test case and autotest creation, reduces QA workload, and accelerates release cycles with high-quality outputs.

When GenAI Steps In: Generating Test Cases and Automated Tests

Previously: every release meant dozens of tasks, hundreds of scenarios, and a large volume of test documentation that the team had to manually create, review, and keep up to date.
Now: you upload requirements and UI designs, and AI generates test cases, suggests automated tests, and captures interface details with high accuracy.

Context

As the product evolved and release frequency increased, the team faced a common scalability challenge in QA: the volume of tasks, scenarios, and test documentation was growing faster than the team’s capacity.
Each release included dozens of tasks, requirements, mockups, comments, and corresponding test cases and automated tests - all of which required manual coordination and maintenance. This significantly extended release preparation time and slowed down the team’s ability to respond to changes.
Routine work became the primary bottleneck: preparing test documentation and continuously synchronizing scenarios. At the same time, regression testing expanded, and validating both new and existing scenarios required increasing effort.
Eventually, it became clear that scaling this process manually was no longer viable. The choice was either to expand the team or to optimize the process itself. This led to a focus on automating test case and test automation generation while reducing manual effort.

Objectives

At the start of the project, we aligned with the client on the desired outcomes:
  • Automate routine tasks so that test cases could be generated from requirements and documentation almost instantly, with minimal manual input
  • Make automated testing more accessible, ensuring tests are generated alongside test cases rather than weeks later, and can be quickly integrated into workflows
  • Achieve “expert-level” quality, ensuring that generated test cases match the quality of manual work, with a target of at least 80% alignment with outputs from experienced QA engineers
  • Ensure transparency, allowing any team member to understand how a test case was generated and easily trace all related artifacts

Solution

We developed a service that automatically generates test cases and automated tests based on requirements and project documentation. At its core is a generative AI model that analyzes input materials, identifies user scenarios, and structures them into test cases.
The system processes not only textual data but also visual inputs. UI mockups and screenshots are analyzed via a Vision API, enabling more accurate representation of real user behavior and interface interactions.
The entire architecture is centered around scenarios as the primary entity. Each scenario stores its full context: requirements, test cases, automated tests, and change history. PostgreSQL is used for storage, ensuring data integrity and scalability across large volumes of scenarios.
The output is a standardized set of test cases in AAA format (Arrange–Act–Assert), including steps, preconditions, and expected results. The system also supports prioritization and traceability to source artifacts, making the results production-ready and easy to maintain as the product evolves.
On top of this, automated test generation is implemented based on the test cases. The system converts scenarios into executable code, taking into account the programming languages and frameworks used by the team, allowing immediate integration into existing QA pipelines.
The result is a unified tool that connects requirements, test cases, and automated tests into a single workflow - reducing manual effort, accelerating release cycles, and making the QA process more structured and transparent.

Results

Initially, the goal was to validate a simple hypothesis: can AI generate test cases of sufficient quality to be used with minimal adjustments?
To test this, real project documentation and requirements were fed into the system, and the output was compared against test cases previously created by experienced QA engineers.
Key outcomes:
  • Most generated test cases were used without modification, significantly reducing the time required to prepare test documentation
  • Automated tests were generated alongside test cases, accelerating the transition from requirements to test execution
  • Manual effort in the QA process decreased substantially, making testing faster and more predictable
  • The system consistently handled diverse input formats and large volumes of documentation, maintaining stable generation quality and adapting well to feedback-driven improvements
Continuous collaboration with the team enabled rapid iteration: duplicate scenarios were eliminated, test case structuring logic was refined, and readability of outputs improved.
As a result, the solution evolved from an experimental tool into a production-ready workflow. Test cases are now generated automatically, automated tests appear almost instantly, and the team can focus more on product development rather than routine QA documentation.
]]>