EDU-4030: evaluate update

docs/evaluate/index.mdx

@@ -1,7 +1,7 @@
 ---
 id: index
-title: Evaluate Temporal
-sidebar_label: Evaluate
+title: Introduction to Temporal
+sidebar_label: Introduction to Temporal
 description: Temporal enhances distributed application development with clear code structure, fault-tolerance, and execution guarantees, trusted by thousands for mission-critical workloads.
 collapsed: false
 toc_max_heading_level: 4
@@ -13,13 +13,16 @@ keywords:
 tags:
   - Temporal
 ---
+Temporal is an open-source platform that makes your applications reliable and durable by default.
 
-Temporal is designed to make developing distributed applications a delightful experience.
-Developers benefit from a clear approach to structure their code and visibility into the state of their application.
-Applications benefit from fault-tolerance and execution guarantees.
-Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads.
+Built for developers, designed for scale. 
+Temporal is code-first, fault-tolerant, and runs seamlessly across any infrastructure. 
+With native support for over six general-purpose programming languages, Temporal eliminates complexity in building and managing distributed applications.
+
+Used by thousands of companies, from startups to enterprises, developers are leveraging Temporal's capabilities for both mission critical and standard workloads across industries.
 
 - [Why Temporal](/evaluate/why-temporal)
+- [Understanding Temporal](/evaluate/understanding-temporal)
 - [Development and production features](/evaluate/development-production-features)
 - [Use cases](/evaluate/use-cases-design-patterns)
 - [Temporal Cloud](/cloud)

docs/evaluate/understanding-temporal.mdx

@@ -30,7 +30,7 @@ Offloading the responsibility of failure management from the application to the
 
 ### Durable Execution
 
-Temporal is a Durable Execution Platform.
+Temporal is a Durable Execution platform.
 Durable Execution ensures that your application behaves correctly despite adverse conditions by guaranteeing that it will run to completion.
 This shift simplifies the development process. If a failure or a crash happens, your business processes keep running seamlessly without interruptions.
 Developers shift their focus on business logic rather than infrastructure concerns and create applications that are inherently scalable and maintainable.
@@ -54,10 +54,9 @@ You've likely encountered Workflows in your daily life, whether it's:
 
 A Temporal Workflow is your business logic, defined in code, outlining each step in your process.
 
-Temporal isn’t a no-code Workflow engine — it is **Workflows-as-Code**.
+Temporal uses a code-first approach.
 Instead of dragging and dropping steps in a visual interface, you write your Workflows in code in your favorite programming language, code editor, and other tools.
-No-code engines eventually hit their limitations however, Temporal gives you full control and flexibility over your business processes.
-This allows you to build exactly what you need.
+No-code engines eventually hit their limitations however, Temporal gives you full control and flexibility over your business processes allowing you to build exactly what you need.
 
 ### Activities
 
@@ -98,7 +97,7 @@ One of the biggest advantages of the Temporal Service is how it handles failures
 The Temporal Service maintains a meticulous record of every step in your Workflows.
 By keeping a history of every step in your Workflow, it ensures that even if something goes wrong your Workflow can continue from the last successful point.
 The Temporal Service knows exactly where to resume without losing any work.
-This saves you from having to write complex error handling code or painstaking recovery mechanisms yourself.
+Using Temporal saves you from having to write complex error handling code or painstaking recovery mechanisms yourself.
 
 You can run the Temporal Service on your own infrastructure or use Temporal Cloud, a managed service that handles operational overhead and offers scalability and expert support.
 
@@ -129,7 +128,7 @@ These are powerful for debugging uses and provide real-time monitoring of your a
 ### Temporal UI
 
 The Temporal UI is a browser-based user interface that allows you to see the progress of your application.
-Also, known as the Web UI, it can also help you to quickly isolate, debug, and resolve production problems.
+It can also help you to quickly isolate, debug, and resolve production problems.
 
 ![Recent Workflows page](/img/webui/workflow-details-page-hiw.avif)
 
@@ -148,7 +147,7 @@ The Temporal CLI provides developers with direct access to a Temporal Service fo
 ## Reliable as Gravity
 
 Temporal provides effortless durability, allowing applications to run for days, weeks, or even years without interruption even if the underlying infrastructure fails.
-This is what we call _Durable Execution_. Temporal also represents a paradigm shift in software development.
+Temporal calls this _Durable Execution_. Temporal also represents a paradigm shift in software development.
 It's not just about making existing patterns more reliable; it's about enabling entirely new approaches to building complex, distributed systems.
 
 Temporal simplifies state management and developers don't have to write tons of extra code to handle every possible thing that could go wrong.

docs/evaluate/why-temporal.mdx

@@ -14,13 +14,19 @@ tags:
 ---
 
 # Why Temporal?
+Modern applications are increasingly distributed - spanning multiple services, databases, and providers. 
+But with that comes complexity:
+1. How do you ensure execution doesn’t break in production when services fail?
+2. How do you manage retries, timeouts, and failures without writing thousands of lines of error-handling code?
+3. How do you track what actually happened in an application when debugging an issue?
 
-Temporal solves many problems that developers face while building distributed applications.
-But most of them revolve around these three themes:
+Developers often manually patch together solutions using queues, retries, external databases, and homegrown orchestration tools. 
+But these approaches are difficult to scale as applications grow, introduce hidden failures, and make debugging challenging - leading to custom tracing solutions, brittle workarounds, and operational burden.
 
-- Reliable distributed applications
-- Productive development paradigms and code structure
-- Visible distributed application state
+Engineering teams commonly find themselves spending significant time implementing and maintaining reliability patterns rather than focusing on core business logic. 
+This trade-off becomes more pronounced as systems scale and reliability requirements increase. 
+
+Temporal provides a structured way to build resilient and durable applications by ensuring execution continues, even in the face of failures.
 
 :::tip See Temporal in action
 Watch the following video to see how Temporal ensures an order-fulfillment system can recover from various failures, from process crashes to unreachable APIs.
@@ -35,30 +41,38 @@ Watch the following video to see how Temporal ensures an order-fulfillment syste
 </div>
 :::
 
+
 ## Reliable execution
 
 **How does Temporal make applications reliable?**
 
-Temporal makes it easier for developers to build and operate reliable, scalable applications without sacrificing productivity.
-The design of the system ensures that, once started, an application's main function executes to completion, whether that takes minutes, hours, days, weeks, or even years.
-Temporal calls this _Durable Execution._
+Failures are inevitable and managing them effectively is critical to maintaining system durability. 
+The design of a Temporal application ensures that, once started, an application's main function executes to completion, whether that takes minutes, hours, days, weeks, or even years.
+Temporal calls this _Durable Execution._ 
 
 ## Code structure
 
 **How does Temporal simplify application code for software developers?**
 
 By shifting the burden of failure handling from the application to the platform, there is less code for application developers to write, test, and maintain.
-Temporal's programming model offers developers a way to express their business logic into coherent _Workflows_ that are much easier to develop than distributed code bases.
+Instead of managing fragile state machines or configuration-heavy workflows, developers write application logic in code using their existing tech stacks.
 
-Choose the SDK that best suits your preferred programming language and start writing your business logic.
+With code-first development, choose the SDK that best suits your preferred programming language and start writing your business logic.
 Integrate your favorite IDE, libraries, and tools into your development process.
 Temporal also supports polyglot and idiomatic programming - which enables developers to leverage the strengths of various programming languages and integrate Temporal into existing codebases.
-Developers achieve all of this without having to manage queues or complex state machines.
 
 ## State visibility
 
 **How does Temporal make it easier to view the state of the application?**
 
 Temporal provides out-of-the-box tooling that enables developers to see the state of their applications whenever they need to.
+Every application's state, progress, and history are accessible in real time, making it easier to monitor, debug, and maintain applications. 
+Debugging is no longer guesswork and developers see exactly what happened and why.
+
 The Temporal CLI allows developers to manage, monitor, and debug Temporal applications effectively.
 The browser-based Web UI lets you to quickly isolate, debug, and resolve production problems.
+
+*What’s Next?*
+- How Temporal Works → Learn the core concepts behind Temporal.
+- Use Cases → See real-world examples of how teams use Temporal.
+- Getting Started → Jump into the docs and run your first Temporal application.

sidebars.js

@@ -3,7 +3,7 @@ module.exports = {
     "index",
     {
       type: "category",
-      label: "Evaluate",
+      label: "Introduction to Temporal",
       collapsed: false,
       link: {
         type: "doc",