Zaina Al Naamani

Sultana Al Burtmani

Reem Al Qarni

Yahya Al Saidi

Shadin Alharthy

Manahil Al Hadabi

Abdur Rahman Awan

Mohammed Al Ghaithi

Waleed Al Harthi 

Aflah Al Abri

Sara Al Harthy

Aleksandr Golovin

Manar Al Mandhari

Habib Al Lawati

Mohammed Bait Othman

Omar Alhendi

Ahmed Al Hasani

Al Azhar Al Mawali

Application and software development is increasingly becoming accessible and manageable by professionals beyond traditional developers, platforms that offer low-code development allow fast and easy application building, by significantly reducing the need to code to deliver an application, allowing both technical and non-technical team members to collaborate and work on the application together.

This article will cover who can make use of low-code development and how to use it to push innovative solutions across different industries.

Low-code is an approach that is used for software development, it enables developers to build applications with minimal code writing while also allowing customization for complex applications, these platforms provide an interface where components are dragged-and-dropped within the workspace to have a visual representation of the application and offering pre-built templates leading to a fast and efficient development process. 

One of the key features of low-code is automation, the repetitive coding jobs are done automatically allowing a speedy delivery time of the application, another important feature is the pre-built integration capabilities that connects external systems to the developed project including databases and APIs, as well as third-party services. 

Scalability is another key advantage of low-code platforms, as they support deployment across both cloud and on-premises environments, allowing applications to grow seamlessly with business needs. 

The most used low-code platforms are OutSystems -used for enterprise-grade applications and offers strong security and scalability, Mendix – Provides multi-cloud deployment and allows developers to utilize AI when creating the application, Appian – Is focused on business process management and automation, Google AppSheet – used for mobile and web apps, these platforms provide different level of complexity, scalability, and focus on certain industries.

Low-code developing is not restricted to developers with technical background only, these platforms are designed to allow users from different professional backgrounds to easily develop applications. Starting off with citizen developers, which are business users that barely have coding experience can use low-code platforms for automating workflows and to build simple applications. Professional developers will be able to make use of low-code platforms to build and integrate applications quickly with the ability to maintain the flexibility of coding. IT teams can leverage this approach to expedite initiatives in digital transformation, and optimize, refine, and enhance development. Thanks to the ease of use offered by low-code development platforms, startups and entrepreneurs can rapidly build MVPs, significantly reducing time-to-market.

Large companies and organizations can have low-code application for internal use purposesand rapid application deployment. As low-code is very useful when it comes to automation, security, and smooth integrations, it works well for industries such as Telecom, finance, and healthcare. 

Telecom companies can use low-code for network automation and IoT integration, and when used in finance, companies can make use of the platform to quickly onboard customers, detect frauds and manage compliance, as for the healthcare industry, patient management, scheduling of appointments, and record keeping is done easily with low-code application development.

Developing through low-code platforms happens through first defining the requirements, then designing the app visually, followed by adding business logic and connecting data sources, then testing and iteration commences before finally deploying and maintaining the delivered application.

When it comes to building an application through low-code platforms, there are multiple core components that allow seamless and efficient development.

Starting off with the visual development interface, drag-and-drop of elements and components such buttons, forms, and workflow is done instead of writing code, allowing developers to visualize the application as it is being built through the graphical user interface (GUI), the GUI is used to design application interface and logic.

Pre-built components are another feature that is used in low-code development, forms, dashboard, data tables, and other common features are available in the platform and ready to use, allowing developers to configure the pages instead of building the pages from scratch.

Low-code platforms also provide the users with reusable modules, for common business functions templates and modules can be reused in different applications.

With the drag-and-drop feature workflows are done visually, the workflows define how the data flows and how the application operates and reacts to user input. For advanced behavior some low-code platforms offer rule-based systems, other platforms use simple scripting.

The use of data integration tools allow developers to connect their systems with external databases, APIs, CRMs and ERPs, the data mapping is done visually as well as synchronizing the data.

One-click deployment is one of the low-code features that stand out the most, with a single click the application is deployed either on cloud, on-premises, or hybrid environments.

Low-code development is powerful and comes with many advantages.One Key benefit include faster development, with the help of pre-built components and the drag-and-drop feature quick development is ensured. Cost efficiency is an advantage that should be considered when developing an application, low-code reduces the need to manually code, therefore, large development teams are not required, hence, minimizing cost for software development and maintenance. 

Improved collaboration is another benefit, low-code allows technical and non-technical teams contributions to the development of the application. Other important advantages are flexibility and scalability, automation and efficiency, enhanced security, easier iteration and updates. 

While low-code development comes with numerous benefits, it also comes with challenges that should be considered when choosing to develop through a low-code platform. Limited customization may come up as an issue if developers want to build a unique and complex functioning application. 

Vendor lock-in is another risk that should be considered because of the difficulty to migrate applications to other environments. Rigid user interface is a disadvantage as customization of the user interface is restricted.

To conclude, developing through low-code platforms enables fast, efficient, and collaborative software developing experience. With the core components such as the drag-and-drop of elements, visual development environment, pre-built component, both technical and non-technical users can contribute to building an application. 

Low-code development allows users from different professional backgrounds build an application. The platform is ideal for different industries such as telecom, finance, and healthcare. Low-code development offers many advantages including speed, efficiency, cost savings and many more, however, the limitations such as customization restrictions should be considered when developing through a low-code platform.

Low-Code: Who and How? 

Part 1: Generative Reward Modeling (GRM) and GRPO: Evaluation and Traditional PPO

The rapid evolution of Large Language Models (LLMs) has unlocked unprecedented capabilities, yet harnessing their full potential demands sophisticated fine-tuning. At Rihal, our commitment to delivering cutting-edge AI solutions means we must continuously explore and implement the most advanced methodologies. This is crucial for developing models that are not only powerful but also accurate, reliable, and deeply aligned with user needs. Adopting state-of-the-art techniques like Generative Reward Modeling (GRM) coupled with Generative-Reward Policy Optimization (GRPO) is therefore a strategic imperative for us. This approach, which moves beyond simple feedback to richer, descriptive critiques, allows Rihal to build superior, client-centric AI, maintain a competitive edge through innovation, and enhance model alignment with nuanced human values. By investing in such advanced paradigms, we aim to push the boundaries of LLM performance, ensuring our solutions are insightful, dependable, and truly beneficial. This article (and its successor) delves into the principles that lead to such advanced techniques.

To understand what's happening, let's begin with how models are evaluated. One of the most effective methods, second only to human evaluation, is 

, where a language model itself is used as an independent judge. This approach commonly relies on two main evaluation methods.

In this scenario, two models—let’s call them Model A and Model B—are given the same task. They each generate a response, and an LLM judge, unaware of which model produced which answer, selects the superior one. After many such "duels," each model receives a ranking using the 

, similar to how chess players are ranked. This enables us to sort models by performance based on how often one "outperforms" another on specific tasks.

Reference-Based Scoring on a 10-Point Scale

The second method assumes the presence of a 

 answer. Here, the judge receives the task, a generated response, and the reference answer. Its task is to assign a score from 1 to 10, evaluating aspects like accuracy, completeness, logic, and style. This allows for a more nuanced understanding of how close a model's response is to an ideal one, especially in subjective tasks.

Both methods are widely used: the first is useful for leaderboard creation and identifying top-performing models, while the second offers deeper insights and diagnostics into generation quality.

We will focus on the second method, as our subsequent exploration builds upon its principles.

When a model acts as a judge and rates answers on a 10-point scale relative to a reference, it becomes crucial for the model to 

 before giving a final score. This "reasoning out loud" approach—where the model first articulates its analysis of the response's strengths and weaknesses before delivering a verdict—significantly improves the consistency and accuracy of the evaluation.

At Rihal, we observed that if you immediately ask the model for a score, it often relies on intuition without analyzing why the response is good or bad. This makes the scores less reliable—the same response might receive different ratings depending on prompt wording or the model’s "mood." However, if the model is forced to first 

 what is right in the response, identify logical gaps, and assess how well the style fits the context, the final score tends to align more closely with human judgment.

This reflective step acts as a self-check: the model structures its understanding, gathers arguments, and thereby stabilizes the outcome. We noticed that this method reduces score variance and increases correlation with human ratings.

To understand what we’re unpacking here, let’s talk about training.

An LLM is the result of a multi-stage training process, with each phase shaping the model’s intelligence. Analogous to human learning, a model first learns to "read" (comprehend patterns), then to "follow instructions," and finally, to "converse and adapt." In AI, these stages are known as 

In this initial stage, the model ingests massive amounts of text: books, articles, websites, code, and dialogues. It’s like giving a child everything there is to read. The model’s task is simple—predict the next word in a stream of text. This is where it gains its foundational knowledge of the world, logic, languages, writing styles, and structure. At this point, it cannot yet follow instructions, but it develops an intuitive "feel" for how language works.

Supervised Fine-Tuning (SFT) — the instruction-following school

After the basics, the model progresses to a new level. Now, it's taught to 

: answer questions, summarize, translate, etc. It learns from labeled examples: given a prompt, here is the desired correct response. The model learns to “obey” and provide accurate, appropriate outputs. At this stage, it becomes more controllable and useful for practical tasks.

Proximal Policy Optimization (PPO) — maturing through feedback

Finally, once the basics are learned, the model begins to 

—much like praise or correction in human learning. PPO is a reinforcement learning algorithm where the model doesn’t just repeat what it’s seen, but 

 its outputs to receive higher "rewards"—typically approval from another model or a human evaluator. This is how it learns which responses users find helpful, polite, or ethical. Here, models start to converse, display tact, and justify answers.

Together, these three stages form the backbone of a well-tuned language model. They enable models not just to memorize and repeat, but to learn to listen, understand, and respond as expected.

Once a model has learned to follow instructions, it enters the reinforcement learning phase—a stage where it begins to 

 comes into play. Instead of simply imitating examples, the model now generates responses and receives 

 indicating how good the response is, typically on a scale from 0 to 1.

—an evaluator trained to judge between responses. The model then updates itself in a direction that increases the likelihood of producing responses that score higher. This phase is crucial for shaping responses to be not only correct but also helpful, polite, ethical, or aligned with human preferences.

Using an LLM as the Reward Model: More Nuanced Feedback

Traditionally, the reward models used in PPO have been relatively simple—often trained classifiers or regressors that return a score based on implicit heuristics. However, they offer no transparency: they merely indicate “this is better,” without articulating 

By replacing this component with a full-fledged 

. The judge receives the task, candidate responses, and optionally a reference answer. It evaluates each response through 

, analyzing aspects like clarity, logic, relevance, factual accuracy, and tone. Only then does it assign a numerical reward—typically still a single value used by PPO to guide learning.

The key advantage here is not merely the score itself but its foundation in 

multi-dimensional, language-based reasoning

. This allows the reward to reflect more 

, improving training outcomes without changing the PPO mechanism.

Integrating an LLM-judge into PPO allows us to preserve the benefits of reinforcement learning—stability, scalability, and policy optimization—while enhancing the 

 that guides the model’s evolution. The model learns not just to maximize a narrow metric, but to align more closely with 

 that resemble human judgment: logical consistency, informativeness, helpfulness, and more.

Although the model doesn’t directly access the judge’s reasoning during training, the improved scoring it receives helps it generalize better. This results in more robust, aligned, and interpretable behavior over time—a step closer to learning not just 

The journey to superior LLMs involves meticulous evaluation and a structured training pipeline. Techniques like LLM-as-a-Judge, particularly when the judge "reasons out loud," provide robust evaluation. The standard training progression from Pretraining to SFT and finally to PPO with an LLM-based reward model lays a strong foundation. This setup, while powerful, primarily relies on feedback for a single generated response at a time. The next evolution in this process, which we will explore in the subsequent article, involves techniques that can leverage multiple samples and richer, descriptive critiques to further enhance model performance and alignment.

Part 2: Generative Reward Modeling (GRM) and GRPO: Enhancing LLM Fine-Tuning with Richer Feedback

In our previous discussion, we explored how Large Language Models (LLMs) are evaluated and trained, culminating in the Proximal Policy Optimization (PPO) with an LLM-based reward model. While this approach enhances feedback quality by leveraging an LLM-as-a-Judge that can "reason out loud," it traditionally processes feedback on a single-response basis. This article introduces Generative Reward Modeling (GRM) and Generative-Reward Policy Optimization (GRPO) – a powerful paradigm that moves beyond single-sample feedback to leverage richer, descriptive critiques across multiple candidate answers, significantly boosting the fine-tuning process. At Rihal, we see this as a key to building superior, client-centric AI.

GRM & GRPO — Learning from Many Answers at Once

 recipe we just covered rests on a simple loop: the policy generates 

 reply, the judge grades it, PPO tweaks the policy, and the process starts over. That minimal feedback works, but it also means the judge never sees the variety of answers the model 

 have produced in that moment. As a result, each gradient step is driven by a single, possibly lucky (or unlucky) sample.

 breaks that bottleneck. Instead of producing a lone scalar score, a GRM generates a concise textual 

 and then assigns a score in plain language. Because the critique is free-form text, the same model can be asked to evaluate 

 candidate answers side-by-side. This broader view is what powers 

GRPO (Generative-Reward Policy Optimisation)

During each GRPO iteration, the policy samples several candidate responses to the same prompt.

The GRM examines the whole bundle, reasons out loud within its critique, and assigns each a score.

Those scores form a richer reward signal; the policy moves toward patterns that consistently place the best-scored answer among its samples.

Because the GRM’s output is textual, we can run the evaluation 

 times with different decoding temperatures. Each run yields a slightly different critique and score distribution. Averaging these independent verdicts smooths out randomness and sharpens the guidance the policy receives. In practice, we see:

: Outlier judgments from any single GRM pass are diluted.

 of strong answers, not just one lucky shot.

: The GRM’s reasoning step forces it to articulate where each answer shines or fails, nudging scores toward criteria humans care about.

AspectLLM-Judge + PPOGRM + GRPOResponses evaluated per step1Multiple (e.g., 2-10+)Feedback formSingle numberFree-form critique + numberVariance controlNone beyond KL penaltyMultiple evaluations, averagedReasoning visibilityOptionalAlways required before scoring

Both frameworks rely on the judge thinking first and scoring second; the difference is that GRM turns that reflection into explicit text and applies it to multiple candidate answers, not just one. The result is a denser learning signal and, after a few training rounds, a policy that not only produces higher-quality first drafts but can generate 

 good answers within the same sampling window.

In other words, GRM + GRPO lets the model learn from 

 the ideas it has, not just the first one that escapes the sampling loop—a small architectural change that unlocks a much richer form of feedback.

Before you copy the snippet into a notebook or a training script, keep these practical notes in mind—they can save the usual “why is nothing happening?” head-scratching:

: Ensure unsloth, async-openai, httpx, and the standard libraries (re, asyncio, os) are installed in the same Python environment that will run GRPO.

: Set OPENAI_API_KEY (and any organization-specific keys) in your shell before you launch the run; otherwise, the asynchronous OpenAI client will raise an exception at the first request.

: The completions argument must follow the OpenAI chat format ([{role: "assistant", content: "…"}]). If you call another backend, adapt the extraction logic so the reward function still receives a list of strings.

: When no <answer> tags are found, the function returns a zeroed reward vector on purpose; this prevents “nan” gradients and keeps the optimizer stable even on bad or malformed data.

: The print statements in the provided code are for illustrative and debugging purposes. They can be modified or removed for production use.

With those guard-rails in place, you can drop the code block below straight into the Unsloth GRPO notebook (or any RLHF loop) and start experimenting with richer, critique-based rewards.

And to keep things simple, we used Unsloth’s notebook implementations for QWEN GRPO training: 

https://docs.unsloth.ai/get-started/unsloth-notebooks

All we need to do to integrate GRM into GRPO is to replace one of the reward functions, something like this:

def correctness_reward_func(prompts, completions, answer, **kwargs) -> list[float]:
    responses = [completion[0]['content'] for completion in completions]
    q = prompts[0][-1]['content']
    extracted_responses = [extract_xml_answer(r) for r in responses]
    print('-'*20, f"Question:\n{q}", f"\nAnswer:\n{answer[0]}", f"\nResponse:\n{responses[0]}", f"\nExtracted:\n{extracted_responses[0]}")
    return [2.0 if r == a else 0.0 for r, a in zip(extracted_responses, answer)]

_BOXED_RE = re.compile(
    r"""          # Any of the following, case‑insensitive
        \*?\*?            # optional '**' from Markdown bold
        \\?boxed          # 'boxed' with *optional* leading back‑slash
        \*?\*?            # closing '**' if it was bold
        \s*[:\-–]?\s*     # optional punctuation after the word
        \{                # opening brace
        ([^}]*)           # capture everything up to the first closing brace
        \}                # closing brace
    """,
    flags=re.IGNORECASE | re.VERBOSE | re.DOTALL,
)

def _parse_scores(text: str) -> list[float]:
    float_pattern = r"-?\d+(?:\.\d+)?"
    m = _BOXED_RE.search(text)
    if m:
        nums = re.findall(float_pattern, m.group(1))
        if nums:
            return [float(n) for n in nums]
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    for line in reversed(lines):
        if "score" in line.lower():
            nums = re.findall(float_pattern, line)
            if nums:
                return [float(n) for n in nums]
    if lines:
        nums = re.findall(float_pattern, lines[-1])
        if nums:
            return [float(n) for n in nums]
    return []

async def _grm_reward_func_async(prompts, completions, **kwargs):
    n_iter = kwargs.get("grm_iterations", 8)
    num_samples = len(prompts)
    common_conversation_text = ""
    for msg in prompts[0]:
        if msg.get("role") == "system":
            continue
        role = msg.get("role", "")
        content = msg.get("content", "")
        common_conversation_text += f"{role}: {content}\n"
    grading_prompt = f"""You are a skilled little expert at scoring responses. You should evaluate given responses based
on the given judging criteria.\n Given the context of the conversation (the last round is the
User’s query) and multiple responses from the Assistant, you need to refer to the [General
Evaluation Criteria] to score the responses. Based on the general evaluation criteria, state
potential other specific criteria to the query, the weights of different criteria, and then provide
an overall comprehensive score upon them.\n Each score is an integer between 1 and 10,
with a higher score indicating that the response meets the relevant criteria more closely. For
example, a score of 1 means the response does not meet the criteria at all, a score of 6 means
the response meets only some parts, and a score of 10 means the response perfectly meets the
evaluation criteria.\n Before scoring, please analyze step by step. Your scoring needs to be as
strict as possible.
#### Evaluation Criteria ####
1. Instruction Adherence:\n - Fully Adhered (9-10 points): The response fully complies with
all instructions and requirements of the question.\n - Partially Adhered (6-8 points): The
response meets most of the instructions but has some omissions or misunderstandings.\n -
Basically Adhered (3-5 points): The response meets some instructions, but the main
requirements are not fulfilled.\n - Not Adhered (1-2 points): The response does not meet any
instructions.\n Example: If the question requires three examples and the response provides
only one, it falls under “Partially Adhered.”
2. Usefulness:\n - Highly Useful (9-10 points): The response provides comprehensive and
accurate information, fully addressing the issue.\n - Useful but Incomplete (6-8 points):
The response provides some useful information, but lacks details or accuracy.\n - Limited
Usefulness (3-5 points): The response offers little useful information, with most content
being irrelevant or incorrect.\n - Useless or Incorrect (1-2 points): The response is completely
irrelevant or incorrect.\n Example: If there are factual errors in the response but the overall
direction is correct, it falls under “Useful but Incomplete.”
3. Level of Detail:\n - Very Detailed (9-10 points): The response includes ample details
covering all aspects of the issue.\n - Detailed but Slightly Lacking (6-8 points): The response
is fairly detailed but misses some important details.\n - Basically Detailed (3-5 points): The
response provides some details but is not thorough enough overall.\n - Not Detailed (1-2
points): The response is very brief and lacks necessary details.\n Example: If the response
provides only a simple conclusion without an explanation, it falls under “Not Detailed.”
4. Relevance:\n - Highly Relevant (9-10 points): The response is highly relevant to the
question, with information closely aligned with the topic.\n - Generally Relevant (6-8 points):
The response is generally relevant but includes some unnecessary information.\n - Partially
Relevant (3-5 points): The response has a lot of content that deviates from the topic.\n - Not
Relevant (1-2 points): The response is completely irrelevant.\n Example: If the response strays
from the topic but still provides some relevant information, it falls under “Partially Relevant.”

#### Conversation Context ####
{common_conversation_text}

#### Responses to be Scored ####
"""

    pattern_answer = re.compile(r"<answer>(.*?)</answer>", flags=re.DOTALL)
    parsed_count = 0  # Track how many of the 8 completions have valid <answer> tags

    for i, comp in enumerate(completions):
        raw_response_text = ""
        if comp and isinstance(comp, list) and comp[0].get("content"):
            raw_response_text = comp[0]["content"].strip()

        match_ans = pattern_answer.search(raw_response_text)
        if match_ans:
            new_response_text = match_ans.group(1).strip()
            parsed_count += 1
        else:
            new_response_text = "I do not know"

        grading_prompt += f"[The Begin of Response {i+1}]\n{new_response_text}\n[The End of Response {i+1}]\n"

    # If no valid <answer> tags were found, skip grading and assign 0 to all.
    if parsed_count == 0:
        return [0.0] * num_samples

    grading_prompt += """\n#### Output Format Requirements ####
Output with three lines:
Specific Criteria: <Other potential criteria specific to the query and the context, and the weights of each criteria>.
Analysis: <Compare different responses based on given Criteria>.
Scores: <the overall comprehensive score of all responses in order, separate by comma in the boxed, e.g., \boxed{x, x} if there exists 2 responses>."""

    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        raise EnvironmentError("OPENAI_API_KEY environment variable not set.")
    client = AsyncOpenAI(api_key=api_key)

    async def get_scores_once():
        backoff = INITIAL_BACKOFF
        for attempt in range(1, MAX_RETRIES + 1):
            try:
                resp = await client.responses.create(
                    model="gpt-4o-mini",
                    input=grading_prompt,
                    temperature=0.5,
                )
                text = resp.output_text.strip()
                scores = _parse_scores(text)
                print("\n---Start---\nLLM Input:\n")
                print(grading_prompt)
                print("\nLLM Output:\n")
                print(text)
                print("\nRaw parsed scores:\n")
                print(scores)
                print("\n---End---\n")
                if len(scores) != num_samples:
                    print(f"Got {len(scores)} scores but expected {num_samples}, skipping this response")
                    return None
                return scores

            except (APIConnectionError, httpx.ConnectError) as e:
                if attempt < MAX_RETRIES:
                    print(f"[Attempt {attempt}/{MAX_RETRIES}] Connection failed: {e!r}")
                    print(f"→ retrying in {backoff} s…")
                    await asyncio.sleep(backoff)
                    backoff *= 2
                else:
                    print(f"[Attempt {attempt}/{MAX_RETRIES}] Connection failed, max retries reached. Skipping.")
                    return None

    tasks = [get_scores_once() for _ in range(n_iter)]
    results = await asyncio.gather(*tasks)

    final_scores = []
    for response_idx in range(num_samples):
        valid_scores = []
        for res in results:
            if not res:
                continue
            if response_idx < len(res):
                # Constrain raw score to [0..10]. If out-of-range, treat as 0.
                raw_val = res[response_idx]
                if raw_val < 0 or raw_val > 10:
                    raw_val = 0
                valid_scores.append(raw_val)

        # Average the valid scores
        if valid_scores:
            avg_score = sum(valid_scores) / len(valid_scores)
        else:
            # No valid scores at all
            avg_score = 0.0

        final_scores.append(avg_score)

    return final_scores

def correctness_reward_func(prompts, completions, **kwargs):
    """
    GRM reward function that evaluates all responses together using _grm_reward_func_async.
    1) If no <answer> tags are found at all, returns all zeros.
    2) Otherwise, raw scores in [0..10].
        - Raw=0 => 0
        - (0..5] => [-1..0]
        - (5..10] => (0..2]
    """
    try:
        raw_scores = asyncio.run(_grm_reward_func_async(prompts, completions, **kwargs))
        normalized_scores = []
        for score in raw_scores:
            # If score is exactly 0, keep it at 0
            if score == 0:
                normalized_scores.append(0.0)
            # If score is in (0, 5], map linearly to [-1..0]
            elif 0 < score <= 5:
                # 5 -> 0,  0 -> -1
                # f(score) = (score - 5)/5 => [-1, 0]
                norm = (score - 5) / 5
                normalized_scores.append(norm)
            # If score is in (5, 10], map linearly to (0..2]
            else:  # 5 < score <= 10
                # 5 -> 0,  10 -> 2
                # g(score) = (score - 5) * (2/5) => (0..2]
                norm = (score - 5) * (2.0 / 5.0)
                normalized_scores.append(norm)

        print("\n---Scores START!---")
        print('\nraw_scores:', [f'{s:.2f}' for s in raw_scores])
        print('\nnormalized_scores:', [f'{s:.2f}' for s in normalized_scores])
        print("\n---Scores END!---\n")

        return normalized_scores
    except RuntimeError as e:
        print("\nError:", e)
        return [0.0] * len(prompts)


Large Language Models (LLMs) achieve optimal performance when 

evaluation and training are tightly intertwined

 provides two complementary lenses: pairwise ELO rankings for quick model sorting and reference-based 10-point scoring for fine-grained diagnostics. (Covered in Part 1)

 stabilizes scores and improves their correlation with human opinion. (Covered in Part 1)

 converts these scores into policy updates, but a single scalar reward per step limits the signal's richness. (Covered in Part 1)

 widen this aperture by evaluating many candidate answers, incorporating written critiques, using multiple sampling passes, and averaging scores. The richer feedback lowers variance, rewards diversity, and teaches the policy 

In practice, the shift from a silent reward model to a generative one typically involves little more than an additional API call, yet it can unlock a markedly steadier learning curve. At Rihal, we have found that even modest experiments—such as eight GRM evaluations per batch and basic score normalization—produce policies that are both 

better at exploring alternative phrasings

swap in a GRM and observe the potential for more stable gradients

. From there, iterate on the critique prompt, tune the temperature mix, and measure—always measure—against human judgments. The iterative loop is simple; the gains, in many cases, are quickly apparent.

Generative Reward Modeling (GRM) and GRPO

To keep up with the fast-paced digital industry, businesses need innovation and smart solutions to stay in the market, low-code development allows the creation of applications quickly and efficiently compared to traditional development, OutSystems is a leading platform when it comes to low-code, it promises to accelerate the delivery of applications while maintaining security and scalability.

This article will highlight the reasons on why choosing OutSystems to develop your application is the way to go.

OutSystems is a full stack low-code software development platform that allows developers to build applications with minimal to no coding. Service Studio is the visual development environment that is used to create the applications and modules, create the user interface, build the data model, define the business processes and debug the application, with OutSystems, you can develop a traditional web, a reactive web, or a mobile application. 

The platform provides functionalities that expedites the delivery of applications such as the drag-and-drop feature which allows developers to visually develop instead of writing lines of code, another feature that OutSystems is known for is the use of reusable components allowing the applications to be consistent and well structured, the feature that stands out and makes OutSystems the leading low-code developing platform is the 1-click publish button, this button will do all the compiling work for you, including the generation of HTML, JavaScript, CSS, and C# code, the application logic, and the deployment of the application to the server or environment. 

OutSystems is all about speed and efficiency, and to achieve that, the platform provides a collaborative environment to allow developers to build applications together and reuse code across the modules and applications.OutSystems supports and encourages code reusability, the Forge is a collaborative repository with reusable modules and components that developers share to help with speeding up the development and delivery time. 

The drag-and-drop feature allows developers to quickly build the interface, automate workflows, and create logic and business processes without the need to code. Service Studio provides app templates to further accelerate the development, these templates are comprehensive with all necessary elements that allows easy personalization of the screen and ensures to substantially reduce development time. 

With these features and built-in functionalities developers have less complexities to deal with, ensuring a fast and efficient development of the application.

Scalability is an important aspect to consider when developing applications, OutSystems is designed for this, it is flexible when it comes to customer requirements, as the demand in the application grows OutSystems handles the load easily, this supports the increase in volumes of data, the number of users, or transactions, hence, the scale can be increased to almost no restrictions. 

Using OutSystems to develop your applications is advantageous when it comes to scalability, the platform promises a seamless growth, as it allows you to develop a small application and without disruption and expensive redevelopment you can expand when needed. 

The architecture of the platform is made to keep up with load balancing and distribute the requests across multiple servers, ensuring consistent performance of the application as it expands.If a component or a server fails, the application will function as usual without disrupting the performance, this is possible because OutSystems is designed to avoid and prevent single points failure.

Another advantage of the platform is its straightforward and simple configuration process for scaling support as the application grows, requiring no complex procedures or significant interruptions.

OutSystems has automation and built-in capabilities for integrating applications with systems, software, and external databases, which significantly reduces the tedious and unnecessary efforts to do these tasks manually. It only requires a few configuration steps to have your database tables ready to be used when integrating with Microsoft SQL Server or Oracle the platform has this feature built-in. 

REST APIs integration is easily done, as all methods and data structures can be integrated with external systems. Error logs and performance information is done automatically because integrations are made to be instrumented, and the integrations with no code required can be managed at run-time within the module. 

OutSystems can be deployed to collect data from multiple enterprise systems, apply business logic, and present customized user-friendly interfaces. 

Therefore, expediting the development process as integration can be done quickly, transfer of knowledge requires less efforts and time, and with the built-in logs integrations are monitored and performance is managed. The integrations are only done by authorized IT users for governance purposes.

Enterprise security is very important when it comes to delivering a safeguarded application, OutSystems is dedicated in providing a completely secure platform and ensuring customers’ data and end-to-end operations are protected. 

The efforts in allowing clients to have a secure platform is very evident with OutSystems, the platform acquired multiple industry-standard certifications including ISO 27001, which is the international standard for information security and management system, PCI DSS, the certification which handles credit card transactions, and SOC 2, this certification is important for services that provide storing data in the cloud, and other important certifications such as GDPR(General Data Protection Regulation) and HIPAA (Health Insurance Portability and Accountability Act). A Security Division is maintained to monitor, analyze, and react to threats that could arise, a thorough investigation and incident analysis is conducted to avoid these incidents and maintain the integrity of the platform.

To conclude, OutSystems stands out when it comes to low-code development platforms, it encourages businesses to rapidly grow and develop scalable applications that are secure and perform smoothly. With Service Studio, reusable components, and the outstanding 1-click publish button ensures a fast and efficient development of applications, along with providing a collaborative environment to allow developers to create applications together, hence, allowing the development team to focus on innovation rather than unnecessary repetitive tasks. 

The built-in integration capabilities of OutSystems, developers can easily configure the database from external systems. OutSystems provide a secure platform to ensure customers’ sensitive data is protected and handled with utmost security.

Why Choose OutSystems

 is a technique where web pages are fully rendered on the server and sent to the browser as complete HTML. This means users don’t have to wait through a blank screen while JavaScript and styles load — they receive a ready-to-view page immediately. This approach reduces load times and improves the perceived performance of websites.

SSR also helps with search engine discoverability and overall performance, especially for content-heavy pages. Since the content arrives pre-rendered, browsers can display it faster. Many modern frameworks, especially those using component-based libraries, support SSR as a core option.

 renders content on the server before sending it to the user’s device.


, on the other hand, builds and displays the page entirely within the browser after loading JavaScript.

Pages with structured, content-rich layouts

Applications where immediate content display boosts usability

Pages where user interaction is more important than fast initial load

Examples: dashboards, admin panels, apps with frequent real-time updates

React 19 brings exciting improvements for server-side rendering:

 that don’t add JavaScript to the client, reducing page load size.

A new hook to handle asynchronous data fetching on the server.

, which allows parts of the page to render and display immediately while other parts load in the background.

, developers can now show some content instantly, improving user experience by not waiting for the whole page.

Next.js 15 builds on React 19’s foundation and improves server rendering and streaming with features like:

 directory structure, optimized for organizing pages and layouts with SSR and streaming in mind.

Better layout and routing tools for easier page management.

Support for breaking pages into smaller streaming sections, so users see meaningful content sooner.

Streaming means users don’t have to wait for the entire page; they start seeing important content as soon as it’s ready.

Setting Up Streaming SSR: A Quick Example

Here’s how you might set up a streaming SSR component in Next.js 15 using React Suspense:

tsxCopyEdit// app/products/page.tsx import { Suspense } from 'react'; import ProductList from './ProductList'; import Loading from './loading'; export default function Page() { return ( <Suspense fallback={<Loading />}> <ProductList /> </Suspense> ); }

 Show parts of the page immediately without waiting for everything.

 Server components cut down on scripts sent to the browser.

 Choose which parts of the page to stream, delay, or pre-render.

 Clear separation of layouts and loading states makes maintenance easier.

Together, these improve responsiveness and user experience without relying solely on client-side rendering.

 where possible to minimize JavaScript payloads.

Organize pages with layouts and nested folders to leverage streaming support fully.

 to keep users engaged during content loads.

Test performance on different devices to ensure streaming actually improves real-world experiences.

Streaming SSR is a powerful approach for building fast, flexible, and maintainable web applications. React 19 and Next.js 15 simplify this with enhanced tooling, better rendering models, and a natural structure for progressive content delivery.

By combining server components, Suspense, and thoughtful layouts, developers can create apps that load faster, feel more responsive, and are easier to maintain. Whether you’re building a product page, portfolio, or interactive interface, streaming SSR can deliver a noticeably better user experience.

Understanding Server-Side Rendering (SSR) and the Future with React 19 & Next.js 15

When the Stakes Are Real: Building a National Exam System That Had to Work

When you’re building an exam system for hundreds of examinees, the pressure isn’t just on them—it’s on the code too.

I didn’t truly understand what “high stakes” meant until I watched over 600 people log into our national exam portal 

. Each of them waiting for their screens to load, timers to start, and answers to be saved—without delay or error. We had spent weeks preparing. But no amount of testing could simulate the sheer intensity of real traffic on exam day.

This is the story of how we built, broke, and fixed a live exam platform—using Blazor, .NET, and a lot of late-night debugging.

We were tasked with building an exam platform for one of Oman’s major health institutions. On paper, the goal was simple: allow hundreds of examinees to log in, take exams, and submit answers in real time. But behind that simplicity was a technical architecture that had to handle:

It worked beautifully in local and dev environments. Then came live traffic.

Things started off smoothly. Users logged in, sessions were stable, timers were in sync. The first exam section went off without a hitch. For a moment, we thought: 

As soon as the second section started, we were hit with the real concurrency test: 600+ examinees back online simultaneously, each one triggering autosaves, submitting answers, and updating timers in real time.

CPU spikes from hundreds of Timer.Elapsed events

The system wasn’t crashing, but it was clearly 

—and silently so. Each Blazor Server session had its own SignalR connection, state, timer, and database context. The architecture was overloaded.

Debugging Under Pressure: Fixing While Live

There was no room for downtime. The exam was still running.


We quickly increased bandwidth and disk space to give the system breathing room. It helped, but we knew that wasn't the root cause.

مقالات رحال

Low-Code: Who and How?

Generative Reward Modeling (GRM) and GRPO

Why Choose OutSystems

Understanding Server-Side Rendering (SSR) and the Future with React 19 & Next.js 15

From Zero to 600 in Seconds: Blazor, .NET, and the Art of High-Concurrency Exams

The Green Stack: How to Code with Sustainability in Mind

PostgreSQL Performance Tips for Write-Heavy Systems: Lessons from the Trenches

Best Practices for Building OutSystems Low-Code Applications

What If Exams Could Think? Building the Next Generation of Assessment in Oman with .NET and AI

Boosting Your Site’s Discoverability with SEO in Next.js

How Jadawel Transforms Data Management into Strategic Clarity

Top Low-Code Platforms in Oman 2025

Beyond Trends: Pick the Right Language for the Right Job

Adapt or Specialize: The Developer’s Dilemma in a Fast-Paced Tech Era

From Login to Logic: Strengthening .NET APIs with JWT & Roles

Building Mobile Apps: Challenges Developers Should Expect.

Q1 at Rihal: Growth and Innovation continues in 2025

Understanding Character Encoding: Why Your Emojis Sometimes Show Up as Boxes

Tokenization Explained: How NLP Models Understand Text

Shaping the Future of UI: The Power of Modern Frontend Capabilities

The Lazy Dev Diaries – Episode 1: But It Works in My Container!

Oman Urban Planning Dashboard with Power BI & GIS

Linux vs Windows: Which Is Better for Programming in 2025?

4 Types of AI to Know in 2025

How RPA Transformed a Leading Telecom in Oman

From Filing Cabinets to AI: Why Omani Organizations Must Digitize Their Data Before It’s Too Late

CodeStacker: Rihal’s Ramadan Tech Challenge Fueling Omani Innovation

Strategic Decision Making: Power BI

مقالات رحال

.css-1enyoca{color:var(--text);-webkit-text-decoration:none;text-decoration:none;}.css-1enyoca:hover{-webkit-text-decoration:none;text-decoration:none;color:var(--text);}Low-Code: Who and How?

Low-Code: Who and How?