From 7b1bfd0edd7b9c60415e83d427168d90551e3dfc Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 15:31:38 -0600 Subject: [PATCH 01/12] update the introductory description of Temporal --- docs/evaluate/index.mdx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index e8a3d32665..e61a57a745 100644 --- a/docs/evaluate/index.mdx +++ b/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,11 +13,11 @@ keywords: tags: - Temporal --- - -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. +Temporal is an open-source platform that makes reliability the default. +It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. +With a developer-first approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. +The best teams rely on Temporal to move fast and build with confidence. - [Why Temporal](/evaluate/why-temporal) - [Development and production features](/evaluate/development-production-features) From 50347c65f754571026e38643de139f0e304c422d Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 15:39:41 -0600 Subject: [PATCH 02/12] slight tweaks --- docs/evaluate/index.mdx | 3 ++- sidebars.js | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index e61a57a745..976042af8e 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -16,8 +16,9 @@ tags: Temporal is an open-source platform that makes reliability the default. It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. With a developer-first approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications. + Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. -The best teams rely on Temporal to move fast and build with confidence. +Developers rely on Temporal to move fast and build with confidence. - [Why Temporal](/evaluate/why-temporal) - [Development and production features](/evaluate/development-production-features) diff --git a/sidebars.js b/sidebars.js index 5aae34a8c0..7963ca60c4 100644 --- a/sidebars.js +++ b/sidebars.js @@ -3,7 +3,7 @@ module.exports = { "index", { type: "category", - label: "Evaluate", + label: "Introduction to Temporal", collapsed: false, link: { type: "doc", From 7edce7fcef1605f129cedaa812c31d02a14a0ee2 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 15:59:49 -0600 Subject: [PATCH 03/12] more edits --- docs/evaluate/index.mdx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index 976042af8e..a3776e8375 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -15,10 +15,10 @@ tags: --- Temporal is an open-source platform that makes reliability the default. It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. -With a developer-first approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications. +With a developer-first approach, a mature testing framework, and language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. -Developers rely on Temporal to move fast and build with confidence. +Developers rely on Temporal to move fast, reduce operational burden, and build with confidence. - [Why Temporal](/evaluate/why-temporal) - [Development and production features](/evaluate/development-production-features) From 532395ef721d2a0feb7c398980519a6da1e779c0 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 16:53:50 -0600 Subject: [PATCH 04/12] first edits to why temporal intro --- docs/evaluate/index.mdx | 4 ++-- docs/evaluate/why-temporal.mdx | 17 ++++++++++++----- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index a3776e8375..21b157d6c9 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -13,9 +13,9 @@ keywords: tags: - Temporal --- -Temporal is an open-source platform that makes reliability the default. +Temporal is an open-source platform that makes your applications reliable and durable by default. It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. -With a developer-first approach, a mature testing framework, and language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. +With a developer-first approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. Developers rely on Temporal to move fast, reduce operational burden, and build with confidence. diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index 0507ee2e0d..c6bf9a18fc 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -14,13 +14,20 @@ tags: --- # Why Temporal? +Modern applications are increasingly distributed. +If your architecture spans multiple services or databases, ensuring reliability, scaling efficiently, and maintaining visibility becomes a fundamental challenge. -Temporal solves many problems that developers face while building distributed applications. -But most of them revolve around these three themes: +Failures are inevitable and managing them effectively is critical to maintaining system durability. +Traditional approaches rely on retries, queues, and ad-hoc state tracking - leading to brittle workarounds, complexity, and operational burden. +Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. + +Developers building distributed applications often encounter three core challenges which Temporal addresses these through three fundamental shifts: + +- Reliability, built in → Applications execute to completion, no matter how long they run or how many failures occur. +Temporal ensures fault-tolerance at scale by managing retries and state without additional complexity. +- Code-first development → Instead of managing fragile state machines or configuration-heavy workflows, developers write application logic in code using their existing tech stacks. +- Execution visibility → 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 - developers see exactly what happened and why. -- Reliable distributed applications -- Productive development paradigms and code structure -- Visible distributed application state :::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. From 6ab74eaf5aa6bc8b9fa9026af96f840d7ea463f8 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 17:09:46 -0600 Subject: [PATCH 05/12] more edits to why temporal --- docs/evaluate/why-temporal.mdx | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index c6bf9a18fc..816ad65cef 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -16,18 +16,15 @@ tags: # Why Temporal? Modern applications are increasingly distributed. If your architecture spans multiple services or databases, ensuring reliability, scaling efficiently, and maintaining visibility becomes a fundamental challenge. - -Failures are inevitable and managing them effectively is critical to maintaining system durability. Traditional approaches rely on retries, queues, and ad-hoc state tracking - leading to brittle workarounds, complexity, and operational burden. -Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. -Developers building distributed applications often encounter three core challenges which Temporal addresses these through three fundamental shifts: +Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. -- Reliability, built in → Applications execute to completion, no matter how long they run or how many failures occur. -Temporal ensures fault-tolerance at scale by managing retries and state without additional complexity. -- Code-first development → Instead of managing fragile state machines or configuration-heavy workflows, developers write application logic in code using their existing tech stacks. -- Execution visibility → 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 - developers see exactly what happened and why. +Developers building distributed applications encounter many challenges, but most of them revolve around these three themes: +- Reliable distributed applications +- Productive development paradigms and code structure +- Visible distributed application state :::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. @@ -48,16 +45,16 @@ Watch the following video to see how Temporal ensures an order-fulfillment syste 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._ +Temporal calls this _Durable Execution._ Failures are inevitable and managing them effectively is critical to maintaining system durability. ## 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. @@ -67,5 +64,7 @@ Developers achieve all of this without having to manage queues or complex state **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 - 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. From 1c7f1d7ffec7a741bc43e10d87dd7263706dbef5 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 17:52:42 -0600 Subject: [PATCH 06/12] new approach to intro --- docs/evaluate/index.mdx | 2 +- docs/evaluate/why-temporal.mdx | 20 +++++++++++++++----- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index 21b157d6c9..2d305aeb8c 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -15,7 +15,7 @@ tags: --- Temporal is an open-source platform that makes your applications reliable and durable by default. It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. -With a developer-first approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. +With a developer-centric approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. Developers rely on Temporal to move fast, reduce operational burden, and build with confidence. diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index 816ad65cef..60912b26aa 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -14,11 +14,18 @@ tags: --- # Why Temporal? -Modern applications are increasingly distributed. -If your architecture spans multiple services or databases, ensuring reliability, scaling efficiently, and maintaining visibility becomes a fundamental challenge. -Traditional approaches rely on retries, queues, and ad-hoc state tracking - leading to brittle workarounds, complexity, and operational burden. +Modern applications are increasingly distributed - spanning multiple services, databases, and providers. +But with that comes complexity: +- How do you ensure execution doesn’t break in production when services fail? +- How do you manage retries, timeouts, and failures without writing thousands of lines of error-handling code? +- How do you track what actually happened in an application when debugging an issue? + +Developers often patch together solutions using queues, manual retries, external databases, and homegrown orchestration tools. +But these approaches can be difficult to scale, introduce hidden failures, and make debugging a nightmare. +It can lead to brittle workarounds, complexity, and operational burden. Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. +Instead of writing complex infrastructure code to handle failures, retries, and state management, developers write normal application logic, and Temporal ensures it runs to completion—no matter what. Developers building distributed applications encounter many challenges, but most of them revolve around these three themes: @@ -39,6 +46,10 @@ Watch the following video to see how Temporal ensures an order-fulfillment syste ::: +- Failures will happen - services crash, APIs time out, and dependencies fail. +- Developers manually write retry logic, state tracking, and recovery mechanisms. +- Debugging failures involves logs, dashboards, and guesswork. + ## Reliable execution **How does Temporal make applications reliable?** @@ -57,14 +68,13 @@ Instead of managing fragile state machines or configuration-heavy workflows, dev 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 - 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. From 4a7c0f641c55efa4be1d578a4c41c36e5b105dac Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 18:20:07 -0600 Subject: [PATCH 07/12] pausing here for now --- docs/evaluate/why-temporal.mdx | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index 60912b26aa..e9ada63da5 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -20,18 +20,14 @@ But with that comes complexity: - How do you manage retries, timeouts, and failures without writing thousands of lines of error-handling code? - How do you track what actually happened in an application when debugging an issue? -Developers often patch together solutions using queues, manual retries, external databases, and homegrown orchestration tools. -But these approaches can be difficult to scale, introduce hidden failures, and make debugging a nightmare. -It can lead to brittle workarounds, complexity, and operational burden. +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 unpredictable challenging - leading to custom tracing solutions, brittle workarounds, and operational burden. -Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. -Instead of writing complex infrastructure code to handle failures, retries, and state management, developers write normal application logic, and Temporal ensures it runs to completion—no matter what. - -Developers building distributed applications encounter many challenges, but most of them revolve around these three themes: +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. +As systems scale, this burden only grows, having developers to build custom tools just to keep things running. -- Reliable distributed applications -- Productive development paradigms and code structure -- Visible distributed application state +Temporal provides a structured way to build resilient 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. @@ -46,9 +42,6 @@ Watch the following video to see how Temporal ensures an order-fulfillment syste ::: -- Failures will happen - services crash, APIs time out, and dependencies fail. -- Developers manually write retry logic, state tracking, and recovery mechanisms. -- Debugging failures involves logs, dashboards, and guesswork. ## Reliable execution From 0a42b21ca746b27610ddfa9a1174bb8378f7da0b Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 18:24:12 -0600 Subject: [PATCH 08/12] small edits --- docs/evaluate/why-temporal.mdx | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index e9ada63da5..96b10b0942 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -21,13 +21,12 @@ But with that comes complexity: - How do you track what actually happened in an application when debugging an issue? 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 unpredictable challenging - leading to custom tracing solutions, brittle workarounds, and operational burden. +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. 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. -As systems scale, this burden only grows, having developers to build custom tools just to keep things running. -Temporal provides a structured way to build resilient applications by ensuring execution continues, even in the face of failures. +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. From a9de3dea0b48d10b683ecfb40170c5b4e7531607 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 18:41:08 -0600 Subject: [PATCH 09/12] changing landing page intro slightly --- docs/evaluate/index.mdx | 7 ++++--- docs/evaluate/why-temporal.mdx | 6 +++--- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index 2d305aeb8c..e764700b4b 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -14,11 +14,12 @@ tags: - Temporal --- Temporal is an open-source platform that makes your applications reliable and durable by default. -It is code-first, fault-tolerant, and designed to run applications seamlessly across any infrastructure. -With a developer-centric approach, a mature testing framework, and broad polyglot language support for over six general-purpose programming languages, Temporal simplifies building and managing complex applications across tech stacks. + +Built for developers, designed for scale. +Temporal is code-first, fault-tolerant, and runs seamlessly across any infrastructure. +With a developer-centric approach, a mature testing framework, and native support for over six general-purpose programming languages, Temporal eliminates complexity in building and managing distributed applications. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. -Developers rely on Temporal to move fast, reduce operational burden, and build with confidence. - [Why Temporal](/evaluate/why-temporal) - [Development and production features](/evaluate/development-production-features) diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index 96b10b0942..551cac8d2e 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -16,9 +16,9 @@ tags: # Why Temporal? Modern applications are increasingly distributed - spanning multiple services, databases, and providers. But with that comes complexity: -- How do you ensure execution doesn’t break in production when services fail? -- How do you manage retries, timeouts, and failures without writing thousands of lines of error-handling code? -- How do you track what actually happened in an application when debugging an issue? +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? 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. From 7c0fec4bdeac5f568271b5e7ef79c516216accde Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Wed, 26 Feb 2025 18:43:25 -0600 Subject: [PATCH 10/12] slight edits --- docs/evaluate/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index e764700b4b..68ac8549bb 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -17,7 +17,7 @@ Temporal is an open-source platform that makes your applications reliable and du Built for developers, designed for scale. Temporal is code-first, fault-tolerant, and runs seamlessly across any infrastructure. -With a developer-centric approach, a mature testing framework, and native support for over six general-purpose programming languages, Temporal eliminates complexity in building and managing distributed applications. +With native support for over six general-purpose programming languages, Temporal eliminates complexity in building and managing distributed applications. Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. From cd4ab187af158e84ad833b0386e4e9f9af03585f Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Thu, 27 Feb 2025 10:03:09 -0600 Subject: [PATCH 11/12] edits --- docs/evaluate/index.mdx | 3 ++- docs/evaluate/why-temporal.mdx | 14 ++++++++++---- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/docs/evaluate/index.mdx b/docs/evaluate/index.mdx index 68ac8549bb..98e3458ff1 100644 --- a/docs/evaluate/index.mdx +++ b/docs/evaluate/index.mdx @@ -19,9 +19,10 @@ 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. -Thousands of companies of all sizes are leveraging Temporal's capabilities for both mission critical and standard workloads. +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) diff --git a/docs/evaluate/why-temporal.mdx b/docs/evaluate/why-temporal.mdx index 551cac8d2e..2d7b5fe1e7 100644 --- a/docs/evaluate/why-temporal.mdx +++ b/docs/evaluate/why-temporal.mdx @@ -46,9 +46,9 @@ Watch the following video to see how Temporal ensures an order-fulfillment syste **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. +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 @@ -64,9 +64,15 @@ Temporal also supports polyglot and idiomatic programming - which enables develo ## 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 - developers see exactly what happened and why. +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. \ No newline at end of file From 3ff32531c638787fb5925a0a02875e12775c3746 Mon Sep 17 00:00:00 2001 From: Jwahir Sundai Date: Thu, 27 Feb 2025 10:09:43 -0600 Subject: [PATCH 12/12] understanding temporal edits --- docs/evaluate/understanding-temporal.mdx | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/docs/evaluate/understanding-temporal.mdx b/docs/evaluate/understanding-temporal.mdx index 256cb7bb81..12e6acd1ef 100644 --- a/docs/evaluate/understanding-temporal.mdx +++ b/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.