*This blog post is a public copy of our monthly newsletter sent on May 23. If you'd like to receive upcoming updates by email, you can[ subscribe to our newsletter here.](https://pages.temporal.io/newsletter-subscribe)*

We've got lots of exciting news this month like...the deadline for CFPs for Replay has been extended to May 31st!

If you have a talk you'd like to share, the window to submit is closing fast - [find out how to submit here.](https://temporal.io/replay?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZnlggSLeL8ivjlsqx0ypjhpXk_z79LhDGn-8GQmwqeQQaGR0uU0WHsr7oXt-GqirjGdCtRXi6XKbvA)

For more information on what we've been working on, just keep reading! 

## Technology

We will be releasing Schedules to Public Preview next month. It has been in OSS, but this means that all Cloud customers can now try it out for free, before we make it officially GA.

We have new updates to the Cloud, see what has changed here:

- [Audit Logging](https://docs.temporal.io/cloud/how-to-manage-audit-logging?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3Ze-EOVqmgUhy1hbN96S3CpzxzqyJjug9ltZpwF-wY2IgJ9ZFOpdMipyh1-YywU_7CaICfhJzx51Ubw) is now available as a Public Preview.
- We are starting a Private Preview for [tcld API Key management and Workflow History Export](https://docs.temporal.io/cloud/tcld?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZoDABQr77fnfv003SyO4Lz6jZLG1pgI_2fIpw4KDMC4eAemXBKqvmvkbv1gi53Z3K0mLd5RdUp2E5A) soon. If interested, please open a support ticket or reach out to Temporal to request early access.

__SDK Updates__
- Our .NET SDK feature is complete! Everything you need to know is in our [Introducing Temporal .NET blog post.](https://temporal.io/blog/introducing-temporal-dotnet?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3Zk-llumf7BcfJl9wGHM6FsjM4ri1xN-3VdJj4JZqAE3GL0IeKvaceMAuqkvBfEI6uZktP5pu5qabAQ)

*__[Audit Logging in Temporal Cloud:](https://temporal.io/blog/audit-logging-in-temporal-cloud-now-available-as-public-preview?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZnvQwtiXXRvHB3fpDqaI7ufL-jHKacNzB_Eb4ncDGO33v2x_OQw-Z1dWjCFtyppRpht75L6mZXtgmg)__ Check out the new feature for Temporal Cloud: audit logging is now available as public preview!*
## Meetups and Events

__Money 20/20 | June 6-8__
- Join us in Amsterdam for [Money 20/20](https://europe.money2020.com/?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZewwqzIxYziDFcP3uAvPoxlOa_rcwE2z7LlEghu-_wz62ikCtWslMSzZUqQMxUhwVjF2-Ud7tOV_BQ) where the industry's leading Financial Services innovators come together to connect and create the future of money.

__Domain Driven Design | June 8-9__
- We'll also be in Amsterdam for [Domain Driven Design](https://2023.dddeurope.com/?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3Ziei_5kP4DxDCDaGKOcNRY407DJxhX-Gq5g7AHTIOq-0qtOAElO4ar-XCUifvUHDuaurUd8z0U0yiw), the premier software modelling and design conference for senior engineers and architects working in complex environments.

__JCon | June 20-22__
- Join us in Cologne, Germany for [JCon](https://2023.europe.jcon.one/?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZbURv5Lj3wxRz1mnzLF_szO_uWKYw7ZCol4iMD3J2cWKgu5rlSFIH9TDJuXhGZ_zVqzEGl6_6OAFug)! Be on the lookout in our Community Slack as we have 30 tickets to giveaway for this event!

## Replay
Replay is back for 2023, and tickets are now on sale! This year, we are bringing together developers, architects, and DevOps professionals who are interested in industry trends and expert-led deep dives. For the second annual Replay conference, we've expanded the number and type of talks and tracks this year.

During the three-day event, you will hear from practitioners, architects, and visionaries who will share their insight, industry experience, and more! The conference includes keynote speeches, technical talks, workshops, and hands-on sessions. We've also expanded our workshop offerings to include Temporal trainings in Go, Java, and Typescript.

Learn more and [register here.](https://temporal.io/replay?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZgE2pTSKXWVibirFpdw7iCovJd349TgedgmS4pKZ2jQ8D98FkGrb-_iRhK_U5rQAbLdogKmBLSIcbg)

## Resources

We launched [Temporal 102 with Go](https://learn.temporal.io/courses/temporal_102/go)! In this course you’ll build on the foundations from Temporal 101 with Go as you explore how to test, debug, deploy, and update applications.

We're excited to announce the expansion of Temporal services including:

- Scale Tests
- Production Readiness
- Technical Onboarding
- Design Sessions

Understand your scalability needs by assessing your setup's performance under varied loads and ensure a smooth development to production transition with a thorough checklist. Self-hosted Temporal users - be sure to check out our Design Sessions. For more information or to get started, please [get in touch with us here.](https://temporalio.slack.com/archives/C046BRWDV2R)

## Community Favorites
- __[Introducing Temporal .NET](https://temporal.io/blog/introducing-temporal-dotnet?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZuSiHeh-diC6nNDZ6OP8VHaroapxQz9Edf5Z_Un8wzgTb9RbIQoTGVFwk7s5XyJLFAZxVI93GD6ibg)__: Add this to your list of Temporal supported languages, the .NET SDK feature is here!
- __[Compensating Actions](https://temporal.io/blog/compensating-actions-part-of-a-complete-breakfast-with-sagas?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZnoWy5ba5hTF64tNof-RwRbhqSdFVVxTVFqRtGPnmFKbBf2KwC4mhjvsLmoAH3esXq9joKGyeCfI5A)__: We've got a new article out on the role compensating actions play in the "complete breakfast with sagas".
- __[Using the Temporal CLI](https://temporal.io/blog/using-the-temporal-cli?mkt_tok=MjUwLVdJVS0wMDcAAAGMDAO3ZnNxxV4o79_2u3ygsc70RGVVWrvniKtpxIK91y1Ltuv9wfWwzJ4UXb1WmNpGPXhylUxEHjczQ0wp0g)__: Check out this new blog that walks you through how to use the new Temporal CLI.

Please, [reach out on our Community Slack](http://temporalio.slack.com/) and let us know if you are building or migrating applications to Temporal and need design assistance. Or request a video covering best practices via [support.temporal.io](http://support.temporal.io/) or [#support-cloud](https://temporalio.slack.com/archives/C046BRWDV2R).


social-orb

This blog post is a public copy of our monthly newsletter sent on May 23. If you'd like to receive upcoming updates by email, you can subscribe to our newsletter here.

Temporal Community Newsletter: May 2023

Charles Zedlewski

charles zedlewski

We just published the first version of our [extension for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=temporal-technologies.temporalio). It currently improves the debugging experience for TypeScript workflows, and in the future we'd like to add other languages, features, and editors. If you have ideas, open an issue in the [GitHub repo](https://github.com/temporalio/vscode-debugger-extension)!

![Temporal for VS Code banner](//images.ctfassets.net/0uuz8ydxyd9p/3ta47lMdxjiUMfU7BjuNOu/18233120dee0bcd59f81376106f46509/vscode.png)

When you run a workflow function, each step it takes is stored as an event in a list called the Event History. You can download a workflow's Event History from the UI or CLI in a JSON file and have an SDK [replay it](https://docs.temporal.io/application-development/testing?lang=typescript#replay): the Worker calls your workflow function with the same arguments, the Worker immediately resolves activity calls with the return values recorded in Event History, and other things like timers going off and signals arriving happen in the same order they did previously. You can set breakpoints in workflow code to see what happened during the workflow's original execution. This ability to replay what happened during a function's execution, whether it's on a coworker's machine or in production, is a great help to debugging.

The Temporal VS Code extension improves the experience of replay debugging. It allows you to:

- Load Event Histories by Workflow Id or JSON file
- Easily start a replay
- Set breakpoints on events, not just code

## Usage

To learn how to use the extension, watch [this video](https://www.youtube.com/watch?v=3IjQde9HMNY) or follow these steps:

- Install [the extension](https://marketplace.visualstudio.com/items?itemName=temporal-technologies.temporalio)
- If you don’t already have a TypeScript workflow, create a project if you don't already have one:

  ```sh
  $ npx @temporalio/create@latest replay-demo --sample vscode-debugger
  $ code replay-demo
  ```

- If you do have a TypeScript workflow, add a file at `src/debug-replayer.ts` (or can [configure](#entrypoint) an alternate location):

  ```ts
  import { startDebugReplayer } from "@temporalio/worker"

  startDebugReplayer({
    workflowsPath: require.resolve("./workflows"),
  })
  ```

  And edit the `'./workflows'` path to match the location of your workflows file. This file is run the by the extension whenever you start a debug session. [`startDebugReplayer`](https://typescript.temporal.io/api/namespaces/worker#startdebugreplayer) creates a [replay Worker](https://docs.temporal.io/dev-guide/typescript/testing?lang=typescript#replay) (like [`Worker.runReplayHistory`](https://typescript.temporal.io/api/classes/worker.Worker#runreplayhistory) does) and communicates with the extension.

- Run `Temporal: Open Panel` (use `Cmd/Ctrl-Shift-P` to open Command Palette)

![Temporal: Open Panel](//images.ctfassets.net/0uuz8ydxyd9p/2G1v2wbMR053JyGmYx7yH6/7a9532b99a92f9ac5279f8c04af47136/open-panel.png)

- Enter a Workflow Id or choose a history JSON file (if you have the `replay-demo` project open, use [this file](assets.temporal.io/debugger-plugin-demo-event-history.json))

![MAIN tab of Temporal Panel](//images.ctfassets.net/0uuz8ydxyd9p/2t0PEQ5n2cWcqT6tfQZhEC/7f5e60bc50bf00256f6ec4c1d5dec996/choose-file.png)

- Click `Start`
- The Workflow Execution will start replaying and hit a breakpoint set on the first event:

![Debug session paused on the first line of the Workflow function](//images.ctfassets.net/0uuz8ydxyd9p/3KXvrYFx4Uspi1aBGb9OBc/e01e77633d1f9f5efe62267f04268c0c/started.png)

- Set breakpoints in code or on history events. Here's a breakpoint on the `sleep` line as well as the history event when the verify Signal arrives:

![Red breakpoint dots on a line of code and an event in the HISTORY tab of the Temporal Panel](//images.ctfassets.net/0uuz8ydxyd9p/71Tu0Kd3AQlIPUrHaoaKNK/59fbc2b9d4c1088111bda55145864a54/set-breakpoints.png)

- Hit play or step forward. In this example, after you hit play, it goes until the `WorkflowExecutionSignaled` event, pausing on the first line of the Signal handler:

![Paused on first line of the Signal handler](//images.ctfassets.net/0uuz8ydxyd9p/c8BL8aKfFaKhhXZ4qjWzJ/56bf202a9605d74032a11a1b14767d02/first-play.png)

  When you hit play again, it stops on the `sleep` line:

  ![Paused on sleep('1 day')](//images.ctfassets.net/0uuz8ydxyd9p/75q5t3IXKBVPmG9WZ9aijg/03c9f23b8549d803ace2a71f9f0c4d57/second-play.png)

  You can see on the top left that the `verified` variable is now `true`.

- To restart from the beginning, click the green restart icon:

![Top bar of debugging icons](//images.ctfassets.net/0uuz8ydxyd9p/14i9m2jSJun0yjnbLGTufe/34b68d8f70d57f8eceff3154bc7cb74b/restart.png)

  If instead of restarting, you step forward or hit play again, the debugging session will end (the replay Worker gets to the end of this history file and exits). Once a debug session has ended, to restart it, go back to the `MAIN` tab and `Start` again.

The `humanVerificationWorkflow` workflow used above is in [`temporalio/samples-typescript`](https://github.com/temporalio/samples-typescript/blob/main/vscode-debugger/src/workflows.ts). For a more in-depth demo, see [this video](https://www.youtube.com/watch?v=3IjQde9HMNY).

## Configuration

### Server

When starting a replay by Workflow Id (and optionally Run Id), the extension downloads the history from the Temporal Server. By default, it connects to a Server running on the default `localhost:7233`.

To connect to a different Server:

- Open the `SETTINGS` tab
- Edit the `Address` field
- If you're using TLS (e.g. to connect to Temporal Cloud), check the box and select your client cert and key

![SETTINGS tab of Temporal Panel](//images.ctfassets.net/0uuz8ydxyd9p/YEkTnasEpExyFnRa4tsUz/552b20eee7e29ed3a120856f6e99751f/settings.png)

### Entrypoint

By default, the extension will look for the file that calls [`startDebugReplayer`](https://typescript.temporal.io/api/namespaces/worker#startdebugreplayer) at `src/debug-replayer.ts`. To use a different TypeScript or JavaScript file, set the `temporal.replayerEntrypoint` config:

- Open or create `.vscode/settings.json`
- Add the config field:

  ```json
  {
    "temporal.replayerEntrypoint": "test/different-file.ts"
  }
  ```

---

That's the extension! If you have any problems with it, please [open an issue](https://github.com/temporalio/vscode-debugger-extension/issues). We also welcome contributions—please get consensus for your plan in an issue before submitting a PR ☺️. Happy debugging! 🐞💃

vscode-feature

Easily debug past or running workflows with Temporal's extension for Visual Studio Code

Temporal for VS Code

Developer Relations Engineer

Loren Sands-Ramshaw

Loren

vscode-social

Companies of all shapes and sizes use [Temporal](https://temporal.io/ "Temporal") [Cloud](https://temporal.io/cloud "Temporal Cloud") to ensure their event-based processes (we call them Temporal Workflows) execute completely and correctly at any scale no matter the level of complexity involved. One of the key requirements for ensuring the reliable execution of these processes is transparency. For many reasons (such as compliance, security, and accountability), it's crucial to have a clear, detailed record of who did what, when, and how. 

Today, we launched a public preview of the [Audit Logging](https://docs.temporal.io/cloud/how-to-manage-audit-logging "How to manage audit logging in Temporal") feature for Temporal Cloud that will allow you to get this critical data. Audit Logging lets you keep track of the actions performed in Temporal Cloud, making it an incredibly useful tool for understanding system behavior, diagnosing problems, and maintaining accountability. 

![audit logging beta](//images.ctfassets.net/0uuz8ydxyd9p/JQ06LOI9ERGR1EwW0mb7w/79ced30d092153b18ec058872a75170b/Screenshot_2023-05-19_at_8.49.22_AM.png)

## Why Audit Logging? 
There are several reasons why you should use the Audit Logging feature:
1. __Compliance:__ Many industries require detailed audit logs for regulatory purposes. With Audit Logging, you can ensure that you're always ready for an audit.
2. __Security:__ Audit logs can be invaluable for detecting suspicious activity. By keeping a close eye on your audit logs, you can quickly identify and respond to potential security threats.
3. __Accountability:__ With a detailed log of all user activity, you can identify who made a particular change to Temporal Cloud. This fosters accountability within your team and helps resolve disputes or miscommunications.

## What's available in the preview?
The preview release of Audit Logging logs information for Temporal Cloud [User](https://docs.temporal.io/cloud/how-to-get-started-with-temporal-cloud#invite-users "Temporal Docs - Invite Users") and [Namespace](https://docs.temporal.io/cloud/how-to-manage-namespaces-in-temporal-cloud "Temporal Docs - Manage Namespaces") administrative operations as well as global configuration operations such as configuring [Observability](https://docs.temporal.io/cloud/how-to-monitor-temporal-cloud-metrics "Temporal Docs - Monitor Cloud Metrics") and the Audit Logging feature itself. You can see the current list of events logged in the [Audit Logging documentation](https://docs.temporal.io/cloud/how-to-manage-audit-logging#supported-events "Temporal Docs - Audit Logging"). The public preview also sends audit events to an AWS Kinesis sink. 

We will keep improving Audit Logging functionality based on user feedback. To date, we've heard users request support for additional destination sinks (such as S3 and GCP) and new auditable events, such as Workflow events. Please stay tuned and watch for updates as this functionality becomes generally available. 

## When will Audit Logging be GA?
At Temporal, we have a maniacal focus on durability, and this means we have a high bar for quality and resilience for all Temporal functionality. During the next few months we will put the feature through additional testing for durability and anticipate achieving general availability within a quarter. Of course, the more preview users who use Audit Logging, the faster we can demonstrate its readiness, so please give Audit Logging a try. 

## Get started with Audit Logging
Using  Audit Logging in your system is simple. We prepared a comprehensive step-by-step guide to walk you through the process. Check out our [How to manage Audit Logging guide](https://docs.temporal.io/cloud/how-to-manage-audit-logging "How to manage audit logging in Temporal") to get started.

## We're here for you
We believe that our new Audit Logging feature will significantly improve your experience with Temporal Cloud, making it easier than ever to maintain transparency, security, and efficiency in your operations. We're excited for you to try it out and let us know your thoughts. 

As always, we're here to support you. If you have any questions or need assistance, don't hesitate to reach out to the Temporal team. 

Stay tuned for more updates from our team. Until then, happy logging!

mehdi-messrro-oOBZb7IfTMI-unsplash

Audit Logging lets you keep track of the actions performed in Temporal Cloud, making it an incredibly useful tool for understanding system behavior, diagnosing problems, and maintaining accountability. 

Audit Logging in Temporal Cloud now available as public preview

Product - Cloud

Jonathan Lacefield

jonathan lacefield

Temporal enables you to write and maintain less code and can help you and your teams adopt and improve a set of distributed systems best practices. Temporal 1.20 introduces several capabilities that extend these best practices to allow you to simplify Temporal development environments and gain more control over scheduling Workflows.

[__Join us for a webinar on 3/30 at 9 am PT discussing the 1.20 release with Product and Engineering from Temporal__](https://pages.temporal.io/webinar-temporal-launch1.20.html)

### Simplify local development with Temporal CLI
Development environments for Temporal have historically been easy to run thanks to our automation, however, under the hood, they’re fairly complex to set up and maintain, as you are required to run multiple containers for Temporal, Elasticsearch, and Postgres. This complexity could even cause issues with reliability within this local environment. 

A few months ago, the Datadog team contributed a project called Temporalite to the community, and with 1.20, we now package it as part of core Temporal. This open-source contribution greatly simplified setting up development environments and allowed developers to get up and running faster. With 1.20, we’ve added the capabilities as the Temporal CLI, which supports convenient installation with [curl, Homebrew, or binary downloads](https://github.com/temporalio/cli#installation) and fully replaces the previous containerized setup. 

```sh
brew install temporal
``` 

```sh
curl -sSf https://temporal.download/cli.sh | sh
```

All of our docs and guides are being updated right now, but we’re really excited to get this into your hands.

Also, in this release, we extend the Temporal CLI with [Advanced Visibility](https://docs.temporal.io/visibility#advanced-visibility), so that you can now query with more flexibility across all of your Workflow Executions to identify issues, recognize usage patterns, and optimize your code without any need for Docker. With this release, we also deprecate the ability to run Advanced Visibility directly on Cassandra without Elasticsearch.

Check out the [Temporal CLI Github](https://github.com/temporalio/cli) repo, and a big thanks to Datadog for contributing to this project! Note: we’ll continue to support Tctl for the next two releases.

### The new way to schedule Workflows in Temporal

Many use Temporal to execute reliable and flexible cron jobs at scale. Until recently, the only way to run a Workflow on a set schedule was with a Temporal Cron Job. However, [Temporal Cron Jobs](https://docs.temporal.io/workflows#temporal-cron-job) could not be stopped or paused, or modified—only deleted. To gain these capabilities, some have relied on external schedulers, like Quartz, to resolve this, but it added implementation complexity and cost.

With 1.20, the new Scheduled Workflows capability is now GA and provides you with the tools necessary to:
- Gain visibility into Schedules and Workflow runs
- Create Schedules that are independent entities (separate from the Workflows they start)
- Have a Schedule specification of when the Workflow should be run that is structured and extensible
- Edit a Schedule’s specification
- Give Schedules a state of either Paused or Running
- Limit the number of runs
- Backfill runs that would have happened during a specific time range
- Overlapping runs are now possible
- Configure policies, for example, “buffer all runs”, “buffer one”, “cancel other”, etc
- Pause-on-failure

This enables you to systematically control scheduled Workflows without getting into an incorrect state and get visibility into scheduled Workflows, control and modify existing scheduled Workflows, and add policies and attributes to keep scheduled and long-running in the correct states. 

Support for Schedules has been added to [the CLI](https://docs.temporal.io/cli/schedule/) and the Web UI, and experimental APIs have been added to the [Go SDK](https://pkg.go.dev/go.temporal.io/sdk@v1.21.1/client#ScheduleClient), the [TypeScript SDK](https://typescript.temporal.io/api/classes/client.ScheduleClient) (see also [a sample](https://github.com/temporalio/samples-typescript/tree/main/schedules)), and the [Python SDK](https://python.temporal.io/temporalio.client.Client.html#create_schedule). Also, check out the [Schedules docs](https://docs.temporal.io/workflows#schedule).

### Scheduled Workflows Demo 

[![Ryland-product-launch-demo](//images.ctfassets.net/0uuz8ydxyd9p/21S4ESfbJxEXcmEeBR30hk/17f54c118ac932b4b97536f2b16da6bb/Screen_Shot_2023-03-20_at_12.56.01_PM.png)](https://youtu.be/sAQxY32vhrg)

[Demo: Introducing Scheduled Actions with Temporal v 1.20](https://youtu.be/sAQxY32vhrg)

A point of clarification in Ryland's demo video: while Scheduled Actions is now the recommended solution for most scheduled scenarios, use cases which require high throughput may be a better fit on the original Temporal Cron functionality.

Additional features launched in 1.20:
- Archival feature reimplemented using a separate task queue
- Replication between clusters with different shard counts
- BatchOperation to support DeleteWorkflow
- OpenTelemetry upgraded to 0.34
- Security-related changes to the Default authorizer (which is confusingly not used by default)
- Internal frontend, which is a new deployment option that can simplify worker→frontend communication, mTLS, claim mappers, and authorizers
- Deprecation heads-up for older MySQL and Postgres versions

[Public release notes](https://github.com/temporalio/temporal/releases/tag/v1.20.0)

[__Join us for a webinar on 3/30 at 9 am PT discussing the 1.20 release with Product and Engineering from Temporal__](https://pages.temporal.io/webinar-temporal-launch1.20.html)


social-card-image

Temporal enables you to write and maintain less code and help you and your teams adopt and improve distributed systems best practices. 

Temporal v1.20: Improved Dev Environments & Workflow Scheduling

Director of Product Marketing

Justin Pirie

justin-pirie-headshot

Temporal v1.20: Lighter & Simpler Development Environments and Improved Workflow Scheduling 

Calling all Pythonistas, we have some good news. Your days of wanting to use Temporal capabilities out of the box, but having to work around it, are over! We are so excited to share that now, thanks to the release of our new Python SDK, it's never been easier to enable [durable execution](https://youtu.be/W0Ygep6iCJY?t=609) in a Python app. Durable execution systems run our code in a way that persists each step the code takes. If the process or container running the code dies, the code automatically continues running in another process with all state intact, including call stack and local variables.

![python](//images.ctfassets.net/0uuz8ydxyd9p/1hk7HB0wd9q2IKMZ5WZ8vT/7f6769aef3b75152e087561c37ba97a9/python-feature__1_.png)

## Why did we create this SDK
Community is at the core of what and why we do what we do. This particular SDK started out as a community-driven one, building on top of our open source core. From there we found that a handful of universities were using it as well. We were so encouraged by the community momentum, we made Python a fully featured, officially supported language with an SDK written and maintained by Temporal. We are looking forward to continuing to iterate on this for our community and we hope to hear from you on how we can make it even better! 

## Installation

### Temporal CLI

```sh
brew install temporal
```

or:

```sh
curl -sSf https://temporal.download/cli.sh | sh
```

or download and extract the [latest release](https://github.com/temporalio/cli/releases).

### Python

Install the `temporalio` package from [PyPI](https://pypi.org/project/temporalio/).

If you’d prefer to isolate and install in a virtual environment, you can follow instructions in our [README](https://github.com/temporalio/sdk-python#quick-start).

## Setup

Run the following command to start the Temporal Server and Web UI process. This will be what the Temporal SDK talks to in order to keep the state of your application.

```sh
temporal server start-dev
```

You should see a bunch of lines of text scroll by—this is the Temporal Server running. Come back and check this terminal tab as you run the app below, you’ll see a lot more information.
If you want to change your namespace, you can pass in a `namespace` parameter to the start command like this: `--namespace=okayest-namespace-name-ever`.

By default, Temporal Server will be running at `127.0.0.1:7233` and you can visit the Temporal Web UI at [`http://127.0.0.1:8233`](http://127.0.0.1:8233).

## Basic Usage of Temporal and Python

Just like any other Python app, you can have an entire application in a single file, and there is a great “hello world”-esque example in our samples repo: [hello_activity.py](https://github.com/temporalio/samples-python/blob/main/hello/hello_activity.py).

To run the example:

```sh
git clone https://github.com/temporalio/samples-python.git
cd samples-python
poetry run python hello/hello_activity.py
```

You should get:

```sh
Result: Hello, World!
```

And you should see the `GreetingWorkflow` execution in the [Web UI](http://127.0.0.1:8233).

## Success is at your fingertips
Et voilà! You’re all set to achieve your hopes and dreams with Python. Temporal can be used in many different ways, to suit your application's needs. To help with that, we have a handful of [sample applications](https://github.com/temporalio/samples-python), depending on what you’re looking for. These should give you an idea of what capabilities you have with Temporal.

You can also learn through reading our any of the following:

- [Temporal Hello World in Python](https://learn.temporal.io/getting_started/python/hello_world_in_python/)
- [Application Developer’s Guide](https://docs.temporal.io/dev-guide/python/)
- [Quickstart Guide](https://github.com/temporalio/sdk-python#quick-start)
- [API reference](https://python.temporal.io/)

Either way, let us know how it goes! Building something cool? We’d love to hear about it! Our forum has a new [Show & Tell section](https://community.temporal.io/c/show-and-tell/56). If you want to share, we’ll send you some sweet swag. Have feedback on how we can do better? We want to know that too. Raise an issue in the [SDK](https://github.com/temporalio/sdk-python) or [samples](https://github.com/temporalio/samples-python) repos, or send us an email (devrel@temporal.io).

## Coming Soon
We are looking forward to building more things with you and are excited to be part of the bigger Python community! We have a lot of exciting things coming down the pipeline this year: updates, events, demos, and more! Some of you may have heard of a little event in the fall, Hacktoberfest, which will have some investment from us this year! So stay tuned, friends, and we’ll see you soon.

Check out the next blog post in this series: [Diving into Workers and Workflows with Python](https://temporal.io/blog/python-sdk-diving-into-workers-and-workflows).

python-social2

Announcing the GA release of our Python SDK, allowing Python devs to write durable code.

Temporal Python SDK: The Release

Head of Developer Relations and Community

Jessica West

jesswest

Python SDK: The Release

Hey friends, we are SO excited to announce that Replay is back this year, and more importantly, we are opening our CFP up to hear from you!

*tl;dr: [Submit your ideas by May 20th](https://www.papercall.io/replay-cfp-2023) for [Replay 2023](https://temporal.io/replay) happening September 12-14th in Seattle!*

Last year we held our very first conference in Seattle, Washington. We had two packed days with workshops and talks that ranged from use cases to the Temporal roadmap to being a change catalyst to the age old topic workflows vs sagas. 

This year, we are going even bigger with more workshops, multiple tracks and additional full day of content. It’s going to be an exciting 3 days, and we would love for you to be part of it.

We need your help to make the 2nd annual Replay the best one yet. The main conference will have slots for 45 minute presentations and 15 minute lightning talks.  We also welcome your proposals for hands-on pre-conference workshops.

We want to hear from you and have a few guidelines we recommend to make it the best possible opportunity for you to speak. 

__We are looking for talks about…__
- Platforms and technologies that make us rethink backend engineering
- New backend engineering practices that have an impact on velocity, productivity, and quality
- Innovative use cases - how successful services & applications were designed and  built or lessons learned from failures
- Architectural renewal: patterns and antipatterns
- Improving the developer experience
- Platform engineering by and for developers
- Taming complexity & improving reliability in services and systems

__Please refrain from…__
- Giving a product pitch.
- Disparaging other companies, languages, or frameworks.
- Submitting third-party submissions.

This year we are launching a program to help new speakers. If you have a great idea, but have given under 5 talks before (including no talks!), this is the program for you! Our Developer Relations team can help you with the best way to take an outline to slides, give you two talk reviews, and ensure you are in the best shape possible for your talk! Make sure to tick the “new speaker” box in the CFP area. 

Here is the [link](https://www.papercall.io/replay-cfp-2023) to apply to speak. The CFP will close on May 20, 2023; we will review all talks and will have a decision for you by June 10, 2023. If you do not hear from us, please know that we are doing our best to go through things in the quickest way possible. We may reach out for clarification on your talk in the interim, but everyone should have an answer by June 10, 2023.  If your talk isn’t accepted for whatever reason, we may reach out to you to speak at one of our meetups instead. We want to encourage all types of conversations amongst our community!

For us, Replay is more than a user conference and a community gathering. We want it to be a source of innovation to help our community create projects we never even dreamed of! Our founders started this company with open source in mind and we are continuing to drive towards that by being good citizens in the community. Our goal is to create an excellent product that you can use and build upon. 

We are 196 days away from the conference and 81 days until [the CFP](https://www.papercall.io/replay-cfp-2023) closes. We’d love to hear from you and hope that you can join us in Seattle this year, regardless! 


social-waves

Hey friends, we are SO excited to announce that Replay is back this year, and more importantly, we are opening our CFP up to hear from you, our community!

Replay CFP and Why You Should Submit

Today, we announced an [additional round of funding for Temporal](https://temporal.io/news/temporal-investors-expand-funding-with-usd75m-round), and while it's exciting for us, it may be more consequential for you – the Temporal user community – as the additional investment will allow us to deepen our focus on delivery of the platform and tools and content that enable you to more easily build on Temporal. Notably, this capital will allow us to double down on our commitment to make Temporal more approachable, applicable, and available to a wider audience of developers.

### Thank you to our growing, vibrant community
Since we started Temporal over three years ago, we have watched the open source community grow steadily around 10-15% month over month. We've also seen a huge increase in engagement in our [Slack community](https://temporal.io/slack) and met a lot of you at in-person (and virtual) events. 

Last fall, we hosted our first of our annual developer conference, [Replay](https://temporal.io/replay), which attracted over 300 attendees in person. The conversations were great, and we were excited that several Temporal users and customers, such as Datadog, Yum Brands, and Netflix, shared their experiences and insights about their use of Temporal. Today, we’ve announced the dates and place for Replay’s second year and [opened up the Replay 2023 CFP](https://www.papercall.io/replay-cfp-2023).  We would love for you to submit your Temporal story or just join us for the event. 

Ultimately, we are grateful for the positive and constructive feedback we've received from our community. It is incredibly helpful for us as we try to get Temporal to be just "right" for every developer, not just all of you early adopters.

### Making Temporal Approachable and Applicable

Our team spends a lot of time thinking about how we can make Temporal even more accessible and easier for you to adopt.

We’ve upgraded the developer experience.  We completely revamped the web UI and continue to add new usability improvements and actions you can perform from the UI.  We’ve added new programming abstractions that make it easier to schedule future or periodic workflows and that support low-latency interactions with running workflows.  We’re hard at work at providing additional ways to manage and deploy versions of your Temporal services.

We recently released our Python SDK as GA, and the .NET and Ruby SDKs are both in development.  This opens up three additional languages to be used with Temporal, alongside Go, Java, PHP, and TypeScript. We want to make the platform available and applicable to whatever you are coding and in whatever language you might use. If you learn through coursework, you can enroll in our [first (free) course on Temporal](https://temporal.talentlms.com/catalog/info/id:126). This is the fourth iteration of a durable execution platform for my co-founder and myself, and it is great to see so many people using it. We really feel that this time around, we are getting the developer experience right. 

We have been happy to see support for the Temporal open source project grow and diversify beyond the founding engineering team.  Thank you for all the proposal comments, issues, and pull requests this past year, especially Datadog who contributed the Temporalite distribution, now checked into our main branch.  Thank you to everyone who’s worked on [libraries and add-ons](https://github.com/temporalio/awesome-temporal) to the Temporal open source project. Thank you to everyone who has helped answer questions and shared advice and support with new community members on our Slack.

We’ve also expanded our developer relations team, headed by Jessica West, with Temporal developer advocates sharing Temporal content, stories, and example apps in many more languages and regions. They are creators and tinkerers, who are focused on helping you more easily adopt Temporal. They also love to travel and would be happy to head out on the road and join a meetup.

### Temporal for all the workloads

Temporal will always be open source and freely available as a production-grade platform, and we will continue to make big advances in its programming model, usability, performance, and reliability. We do not just talk open source, we live it. We’ve also heard from many of you that you wanted the reliability and simplicity of programming with Temporal but without the production headaches of running and managing the Temporal server.  Six months ago we expanded access to [Temporal Cloud](https://temporal.io/cloud), where we now transparently run a global fleet of Temporal servers as a utility delivering a reliable, scalable Temporal namespace  as a service. Currently Temporal Cloud is available in 9 regions starting at $0.000025 per action. Everyone from small teams to even the most complex, large enterprise engineering organizations can benefit from  Temporal without the burden of managing their own server and persistence. 

On behalf of all my fellow Temporalians, thank you for coming along with us on this journey. We are excited about the years ahead and building this project and community together.


social-card-water-effect

Today, we announced an additional round of funding for Temporal, and while it's exciting for us, it may be more consequential for you – the Temporal user community  – as the additional investment will allow us to deepen our focus on 

Doubling Down on Developers

CEO and Co-Founder

Maxim Fateev

maxim fateev

We are pleased to announce that Temporal Cloud is no longer designated "developer preview" and is now in "expanded access!"

Temporal Cloud opened to developer preview in 2021, and during the course of the past year we have onboarded more than 100 organizations to the service.  A sincere thank you to all the members of the community that joined the preview from the earliest days.  Thanks to this collaboration, Temporal Cloud is the simplest, most reliable and affordable way to incorporate durable execution to software services & applications.

What is "expanded access" and why don't we just say GA?

Most importantly, "expanded access" means *no more waitlist*.  We have taken down the waitlist signup and replaced it with [a simple form to sign up for Temporal Cloud](https://pages.temporal.io/cloud-request-access.html).  If you're working for a company that wants to use Temporal Cloud and you are comfortable with our regions, pricing, and terms of service, we'll onboard you to the service within a week.

Our experience powering Temporal workloads large and small, in development and in production, and our recently added self-service features give us the confidence we can keep up with the interest in the service.  We added as many customers in the past 6 weeks as we have in the previous 18 months.  We’re happy with the user feedback and service performance so far.

Temporal Cloud will become fully generally available when there is no time lag between signup and onboarding, when we can offer accounts to users as well as companies, and when we can offer access to organizations that opt to decline production support (currently we require this).  Meanwhile, [Temporal Cloud is available for production workloads from 0.1 - 100,000+ actions per second in 7 regions](https://temporal.io/cloud).

We have an exciting roadmap planned for Temporal Cloud.  We plan to make ever greater advances in:

- Simplifying the experience of adopting and productionalizing Temporal with better automation and self-service features
- Continuing to lower the total cost of running Temporal services and applications
- Further expanding the “operational envelope” of Temporal Cloud namespaces; improving the upper limits and the uniformity of our throughput, scaling, uptime, and latency
- Adding to the set of features that cater to enterprise needs around operations, security, business continuity, and platform teams.

To keep abreast of the latest updates to Temporal Cloud, please join our [monthly newsletter](https://pages.temporal.io/newsletter-subscribe) where you’ll learn about this and other improvements we are making to the Temporal open source platform and to resources we provide to the developer community.

Thanks again for your support of the Temporal open source project and our company.

social-sphere

We are pleased to announce that Temporal Cloud is no longer designated "developer preview" and is now in "expanded access!"

Temporal Cloud is Now Expanded Access

I recently had the honor of teaching Temporal 101 at our inaugural [Replay conference](https://temporal.io/replay "Replay conference") in Seattle. With more than 100 people attending that session, it was one of the largest live hands-on training classes I've ever taught. For every developer who had the opportunity to participate that afternoon, I imagine that at least 10,000 could not. 

Fortunately, you won't have to wait for Replay 2023 or even book your flight to Seattle to learn Temporal. We recently published an online, self-paced version of the [Temporal 101 course](https://temporal.talentlms.com/catalog/info/id:126 "Temporal 101 course"). It's ideal for developers who are new to Temporal and want to quickly learn the fundamentals. 

Best of all, this course assumes no prior knowledge of Temporal and is completely free. Registration is required, however, so that you can save your progress and we can verify course completions. The course combines written content, videos (with complete transcripts), assessments, and hands-on exercises. We find that most learners can complete the course in about two hours, but you can go as slow or as fast as you like. 
![blog-Temporal 101-1](//images.ctfassets.net/0uuz8ydxyd9p/4mTo83itg6zjkQQT8gjWEz/2c8191df7efb32a8ff38c80795ae1578/blog-1.png)

### Little To No Experience Needed
Although the code examples and hands-on exercises are written in Go, they are presented with explanations and avoid advanced Go language features. Learners have reported success with the course despite having little or no experience with Go.
![blog-Temporal 101-2](//images.ctfassets.net/0uuz8ydxyd9p/77hYlMRHDRwifgZSHSqyqZ/5b1145ed5f6203dc2311b7ebbe1d0c47/blog-2.png)

### It's Easily Accessible
I understand that not everyone is able or willing to install software on their computers. That's why this course uses a browser-based exercise environment provided through [GitPod](https://gitpod.io "Gitpod"), available at no cost to you. Using a standard Web browser such as Chrome or Firefox, you'll have access to a private Temporal Cluster, as well as terminal windows where you can type commands and an editor you can use to write your code. The only thing you'll need besides a Web browser is a [GitHub](https://github.com "GitHub") account that you can log into from that browser. (GitPod uses your account to install the exercise code you use during the course.)
![blog-Temporal 101-3](//images.ctfassets.net/0uuz8ydxyd9p/3366rSrzeYuidLHsqZJ6VR/cca9e566fd57d860894cca343b0d3cac/blog-3.png)

We announced this course more than a week ago to members of our Temporal Education Updates mailing list. If you'd like to be among the first to learn about new courses, including the availability of *Temporal 101* for other programming languages, I encourage you to [sign up](https://pages.temporal.io/get-updates-education "sign up") so we can notify you, too.

We recently published an online, self-paced version of the Temporal 101 course - ideal for developers who want to quickly learn the fundamentals.

Self-Paced Temporal 101 Training: Learn Anywhere and Anytime

Principal Curriculum Developer

Tom Wheeler

Free Self-Paced Temporal 101 Training: Learn Anywhere and Anytime

After almost 2 years of development, 736 commits, 441 pull requests, and 49 releases, we've finally published the stable `1.0.0` version of the Temporal TypeScript SDK. In this post, we'll share what's special about this SDK, how it's been built, how we've improved the API, and our future plans.

> For those new to [Temporal](https://temporal.io/), we think of it as a "durable code execution framework." We execute your backend code in a durable fashion: by persisting each step your program takes, we can recover your program's state in the event of failure—even if the machine goes offline or loses power in the middle of execution. We also durably retry and timeout external calls, so if your services or databases are unreachable or returning errors, we will keep retrying until they're back in a good state. This allows backend engineers to develop at a new, higher level of abstraction that is oblivious to faults in the system. See also a [video introduction](https://twitter.com/lorendsr/status/1544806504443695104?s=20&t=XFYNWSB8BEroAhjA6ATDPQ) and [formal definition](https://docs.temporal.io/temporal).

We call it the TypeScript SDK, but we designed it for TypeScript and JavaScript developers alike.

## What makes this SDK unique?

### Deterministic sandboxed workflow runtime

The SDK leverages V8 isolates (the technology behind Chrome's isolation) to run each Workflow in an isolated JavaScript runtime to get a distinct global scope and to prevent the use of "unsafe" JavaScript modules that could break the code's [deterministic constraints](https://docs.temporal.io/workflows#deterministic-constraints). All non-deterministic JavaScript APIs, such as getting the current time or a random number, have been replaced with [deterministic versions](https://docs.temporal.io/typescript/determinism#sources-of-non-determinism).

With all of this put together, we eliminated an entire class of footguns and made it easier to get started with Temporal. Realizing the benefits of the deterministic runtime, we've set the tone for the future of Temporal SDKs. We'll strive to bring this added safety to the older and upcoming SDKs.

### Reliability through a shared Core

This is the first stable SDK built on top of a shared Rust Core SDK (see [blog post](https://docs.temporal.io/blog/why-rust-powers-core-sdk/) and [repo](https://github.com/temporalio/sdk-core/)). We started developing the Core SDK around the same time as the TypeScript SDK, and the API boundary between the two evolved over time.

Most of the complex concurrency management and state machine logic is in Core, which means that:

- We can build new SDKs and features much faster. For example, our [Python SDK](https://github.com/temporalio/sdk-python) (currently in alpha) was built in just a few months. - Our SDKs are more reliable: When a problem is fixed in Core, it is fixed for all Core-based SDKs. Our previous SDKs implemented the complex logic differently, and have had very different bugs and quirks.

## Built with the community

When we released the first alpha version of the SDK back in March of 2021, we set out to iterate on the public API and have asked our community of users to help us shape it.

We've been very fortunate to have received such wide adoption for the SDK, especially at such an early stage. The SDK's Slack channel ([#typescript-sdk](https://temporal.io/slack)) has grown to more than 1200 members, and we've been actively responding to and supporting users on a daily basis.

The feedback and trust we've gotten from our early adopters has been invaluable. We wouldn't have been able to reach API and functional stability without them. Thank you for putting up with our [many breaking changes](https://github.com/temporalio/sdk-typescript/blob/main/CHANGELOG.md) during the alpha and beta. From now on, we are committed to maintain backwards-compatibility for Core APIs and history replayablity, and to miminize backward-incompatible changes for non-Core APIs.

A special thank you to everyone [who contributed](https://github.com/temporalio/sdk-typescript/graphs/contributors) to the SDK's development—[Sushisource](https://github.com/Sushisource), [vkarpov15](https://github.com/vkarpov15), [mjameswh](https://github.com/mjameswh), [JoshuaKGoldberg](https://github.com/JoshuaKGoldberg), [yoDon](https://github.com/yoDon), [SamSokolin](https://github.com/SamSokolin), [julianocomg](https://github.com/julianocomg), [vitarb](https://github.com/vitarb), [joebowbeer](https://github.com/joebowbeer), [andreasasprou](https://github.com/andreasasprou), and [jameslnewell](https://github.com/jameslnewell)—and to [swyx](https://twitter.com/swyx) for writing and recording most of the [docs and tutorials](https://docs.temporal.io/typescript/introduction/) and tirelessly advocating for API simplication. We welcome more involvement from anyone, from helping answer community questions to submitting issues or PRs—check out [CONTRIBUTING.md](https://github.com/temporalio/sdk-typescript/blob/main/CONTRIBUTING.md) for more information.

## The journey

Since the first release of the SDK, we've made significant changes to the public API.

We went from Workflows that look like this, where a Workflow interface was required, we relied on path aliases, and the Workflow name was based on the containing file—

**proposal - stage 1** 

```typescript 
import { Example } from '@interfaces/workflows';
import { greet } from '@activities/greeter';

async function main(name: string): Promise<string> { 
  const greeting = await greet(name); 
  console.log(greeting); 
}

export const workflow: Example = { main }; 
```

—to this, where Activities are proxied using their types and Workflows names are function names—

**alpha - stage 2**

```typescript
import { createActivityHandle } from '@temporalio/workflow';
import { Example } from '../interfaces';
import type * as activities from '../activities';

const { greet } = createActivityHandle<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export const example: Example = (name: string) => ({
  async execute(): Promise<string> { 
    return await greet(name); 
  }, 
});
```

—to where we are today, where Workflows are just functions and don't require interface definitions:

**stable - stage 3**

```typescript
import { proxyActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { greet } = proxyActivities<typeof activities>({ 
  startToCloseTimeout: '1 minute',
});

export async function example(name: string): Promise<string> { 
  return await greet(name);
}
```

## The future

Now that the SDK is stable, we will invest in even safer APIs to help steer users in the right direction by avoiding common anti-patterns, and we will invest in developer tools that make the local development experience better, like IDE plugins.

There are many more general Temporal features planned this year, including:

- Synchronous Updates (like a Signal, but can return a value) 
- Better versioning 
- More languages: [Python](https://github.com/temporalio/sdk-python) is close to beta and more will be announced later this year.

## Learn more

To learn more about using the TypeScript SDK, check out [our docs and tutorials](https://docs.temporal.io/typescript/introduction/). If you have questions, you can post a new topic with the `#typescript-sdk` tag on our [community forum](https://community.temporal.io/).

We're building Temporal because we want to enable developers to easily build highly reliable applications. We hope you find it useful!

*💬 Discuss on [Hacker News](https://news.ycombinator.com/item?id=32240822), [Reddit](https://www.reddit.com/r/node/comments/w8ohkv/100_release_of_the_temporal_typescript_sdk/?), [Twitter](https://twitter.com/lorendsr/status/1551971037667098624?s=20&t=rTTXWjVPqRJ3IwibrjZSkA), or [LinkedIn](https://www.linkedin.com/posts/lorensr_typescript-javascript-temporal-activity-6957736682683039744-z29P?utm_source=linkedin_share&utm_medium=member_desktop_web).*


typescript-sdk

After almost 2 years of development, 736 commits, 441 pull requests, and 49 releases, we've finally published the stable version of the Temporal TypeScript SDK!

1.0.0 release of the Temporal Typescript SDK

Engineering

Roey Berman & Loren Sands-Ramshaw

roey-loren

*Update: v2 is now the default Web UI. To try it out: install [the CLI](https://github.com/temporalio/cli#readme), run `temporal server start-dev`, and open [localhost:8233](http://localhost:8233).*

We're excited to announce the public beta of the new Temporal UI, which is available today as an opt-in feature for our open source users. We’d love [your feedback](https://github.com/temporalio/ui/issues).

![159999018-d82dfe25-394b-4332-b6e8-a4fedeceec34](//images.ctfassets.net/0uuz8ydxyd9p/5W5ooANY9KiGkFK1DXNPuV/ce3951c20624fe957a9dbe348dee9489/159999018-d82dfe25-394b-4332-b6e8-a4fedeceec34.png)

The new Temporal UI is a ground-up rewrite. This first release aims for parity with the current UI. Our goal was to lay the foundation for an architecture that we can iterate on. We'll continue to ship features and functionality for the foreseeable future. We also think it looks pretty nice.

We addressed dozens of quality-of-life issues and improved the performance of the user interface. We built the new web experience with [Svelte](https://svelte.dev/), which supports many of the best practices of modern web development. Svelte does the majority of its magic at compile time, which limits the amount of code shipped to operate the application at run time. The result is a significantly smaller application bundle and noticeably snappier performance.

![160000073-fcc79ef6-4be3-4f4a-98c8-2831007a26f6](//images.ctfassets.net/0uuz8ydxyd9p/64FDx5ZtpsBT5m4CPyoxB5/dc14fdf20e25ae1c71a65b09bffd506e/160000073-fcc79ef6-4be3-4f4a-98c8-2831007a26f6.png)

We snuck in some new features along the way. In addition to a fresh look and feel, you'll notice that it's easier to see whether you're using a [Data Converter](https://docs.temporal.io/concepts/what-is-a-data-converter/). We store filter settings and queries in the URL. This means that sharing what you're currently looking at with your team is as easy as sharing a link.

The new user interface will eventually be the default experience for working with Temporal in the browser. In the meantime, we'd love for you to try it out as we continue to iterate on it. Taking the new UI for a spin is incredibly easy. If you pull down the latest version of Temporal’s [docker-compose](https://github.com/temporalio/docker-compose), it’s already running alongside the current UI but on port 8080.

![160000081-77f1b8b8-2c60-44b4-ab41-7461bcf9b558](//images.ctfassets.net/0uuz8ydxyd9p/3buqc5vtSgB4H2myvMRl84/bccbbfddaa73bebe856e30703e56f4fd/160000081-77f1b8b8-2c60-44b4-ab41-7461bcf9b558.png)

Big changes to the user interface can be tricky when you’re running mission-critical software like Temporal in production. For the time being, you can run both experiences in parallel. We’ll continue to support the existing UI as we polish and iterate on the new UI. But, over the next few weeks, we’ll begin to direct new users to use the new UI. We’ll release new versions multiple times each week as we get your feedback and solve for your use cases. On September 30, 2022, we’ll remove the current UI.

This is only the beginning for us. We have a lot of exciting features planned, now that we have this new architecture in place. We'd love to hear from you. If you encounter any issues or have any ideas for features that you'd like to see, file an issue in [our repository](https://github.com/temporalio/ui).


159999018-d82dfe25-394b-4332-b6e8-a4fedeceec34

We're excited to announce the public beta of the new Temporal UI, which is available today as an opt-in feature for our open source users.

Temporal UI v2 is Now in Public Beta

Head of Engineering, Frontend

Steve Kinney

steve kinney


When we [announced our Series B fundraising](https://www.youtube.com/watch?v=RA7gRSXUXls), we also decided to experiment with live Intro and Q&A sessions for the thousands of developers who would be hearing about us for the first time. We had a blast connecting with many of you individually and your feedback keeps us improving for next time!

We also knew that most of you wouldn't be able to make it live, so we make a rule of recording it for you to catch up async (Temporal is nothing if not good at async)! Here's what you missed ([full playlist here](https://www.youtube.com/watch?v=2HjnQlnA5eY&list=PLl9kRkvFJrlTbzEx02mzQP7H0HDGbuZuM)):

## Funding Livestream Q&A

[Video: Temporal Series B Livestream](https://www.youtube.com/watch?v=E40KwlxZJFI&t=634)

This 50 minute session was the only actual livestream we did, meaning no edits were possible, but it went well thanks to the almost 200 of you that joined us to celebrate our big day.

Topics covered:

- Recap of Temporal's explosive 2021
- Details of Temporal's Series B, where the money is going, and some behind-the-scenes on the unusual fundraising process
- Q&A: What kind of engineers is Temporal hiring? What are Temporal's IPO plans? What's the status of Temporal UI? What's the status of the upcoming .NET and Python SDKs?

## SDK Intros

We also made intro sessions for each of our first party SDKs:
- [Intro to Temporal with Go SDK](https://www.youtube.com/watch?v=-KWutSkFda8)
- [Intro to Temporal with Java SDK](https://www.youtube.com/watch?v=1RY2lWSuJaA)
- [Intro to Temporal with Typescript SDK](https://www.youtube.com/watch?v=66zQ8nrW-mA)

Each of them are subtly different so you get a "set bonus" if you watch them all:

- In the Java Intro, we had [Dmitry Spikhalskiy](https://www.linkedin.com/in/spikhalskiy/), who previously used the Java SDK at Apple and now maintains it, speak for the first time on how he views Temporal in relation to standard Java ecosystem tooling
- In the Go Intro, we had [Chad Retz](https://github.com/cretz), language wizard who maintains the Go SDK and is now working on [the upcoming Python SDK](https://github.com/temporalio/sdk-python), talk about his conceptual understanding of the Go SDK
- In the TypeScript Intro, we were joined by maintainer and SDK team Principal Engineer [Roey Berman](https://il.linkedin.com/in/roey-berman-05018029) for a full Q&A on workflow versioning and other hard problems

## Business Use Cases and Architecture

Developers primarily experience Temporal via the SDK's, but we also wanted to boost your application-level and conceptual understanding of Temporal as well.

In a rare event, all three Product leads of Temporal presented about our top use cases for the first time. 

[Video: Top 3 Use Cases for Temporal](https://www.youtube.com/watch?v=eMf1fk9RmhY)

Covering our top 3 usecases:

- Long running processes (exemplified by Checkr)
- Business transactions (exemplified by Box)
- Infrastructure provisioning (exemplified by Datadog)

Our Developer Advocate Dominik Tornow also presented [a session on Temporal's underlying architecture](https://www.youtube.com/watch?v=wMUKhtRhlmY).

All in all, it was a very productive Series B week for us with hopefully a refreshed and updated set of starting points for you to begin your Temporal Journey! Please [reach out to me](mailto:community@temporal.io) if you have requests for any other content, and join our next [monthly Flagship meetup](https://temporal.io/meetup) to stay up to date with the latest and greatest in Temporal!


omar-flores-lQT bOWtysE-unsplash

When we announced our Series B fundraising, we also decided to experiment with live Intro and Q&A sessions for the thousands of developers who would be hearing about us for the first time.

All our Series B Intro presentations are now up

Developer Relations

swyx

Today Temporal Technologies announced the $103M round of financing [led by Index Ventures](https://www.indexventures.com/perspectives/everything-is-a-workflow-our-investment-in-temporal/) with all our major investors (Sequoia, Amplify, Addition, Madrona) participating. This brings the company to a 1.5 billion valuation. We welcomed [Mike Volpi](https://www.linkedin.com/in/mavolpi/) to the company board. We are really excited to leverage his vast experience helping to build iconic open-source companies.

Five years ago Uber's growth was explosive. Its developers were spending the largest portion of their time not on the new features but on ensuring the reliability of their code. Samar and I had a vision and experience to help them. Thus the new project was born. We didn't realize it back then, but all the stars had aligned to create something that had the potential to affect the whole industry.

- We innovated a new way to write reliable applications that developers really liked.
- The platform was designed and built as a highly scalable multi-tenant service from the get-go.
- It was battle tested at Uber through dozens of use cases.
- It was built as an open-source project under a permissive MIT license.

We had the vision but still weren't prepared for how fast a strong community formed around the project. It was amazing to learn how software products and services that all of us use daily rely on Temporal to power critical business use cases. We were really grateful to the early adopters. Their trust and enthusiasm encouraged and helped us to start Temporal.

The company is a little over 2 years old, the community has grown exponentially, and it is just the beginning. We made a decision to keep the MIT license and to avoid having proprietary components (aka open-core model). The only way we plan to monetize the project is by providing a hosted offering (Temporal Cloud). Our cloud already has dozens of paying customers, from single-person startups up to publicly traded companies. We are working hard on the general availability of our cloud.

We recently asked ourselves how we would define Temporal's success. We decided that we are not there until:

- Reliability is easy and inexpensive for applications of all sizes.
- Every developer is aware of Temporal and understands its value proposition.
- Developers of any skill level and experience can use Temporal.
- A namespace in Temporal Cloud becomes as reliable, predictable, and commonplace as an S3 bucket.
- There is a vivid ecosystem of open-source projects that leverage Temporal as an underlying engine.

The new financing validates our business model and gives us the opportunity to pursue these goals.

How we plan to use this new funding to help you:

- **Improve our open-source software**.  We'll have an update on this later today if you [join our live stream](https://www.youtube.com/watch?v=E40KwlxZJFI).
- Create more and better **public goods for the developer community**, adding education, conferences, and community support to what we already do.
- **Enhance our cloud service** to make it available to everyone.
- **Grow the ecosystem** of technologies that work with or build on Temporal.

How you can help us:

- Spread the word - so many of our best user stories started with one engineering team learning about Temporal by word of mouth.
- Participate in the community - we are committed to building out in the open and want your participation and your feedback.

If you're reading this and are new to Temporal:

- [Sign up](https://calendly.com/community-temporal) for the live introductory sessions we're running this week and next.
- Or explore some of the common Temporal [use cases](https://temporal.io/use-cases) and [get started](https://docs.temporal.io/).


temporal-home-page-feb-2022-64d2efffbe34c54f2d922803b8e74447

Today Temporal Technologies announced the $103M round of financing led by Index Ventures with all our major investors (Sequoia, Amplify, Addition, Madrona) participating.

An Open Letter to the Temporal User Community

We have just announced our Series B fundraising, with a [letter from Maxim](/blog/series-b-announcement-open-letter), [announcement from Byran Offutt at Index Ventures](https://www.indexventures.com/perspectives/everything-is-a-workflow-our-investment-in-temporal/), a fun [teaser video](https://www.youtube.com/watch?v=RA7gRSXUXls) and [community Q&A](https://www.youtube.com/watch?v=E40KwlxZJFI)!

Externally, we also enjoyed good press coverage. We collected them all here in one place for whoever is looking for this information in future:

  - **[Geekwire](https://www.geekwire.com/2022/temporal-is-a-unicorn-developer-productivity-startup-lands-120m-at-1-5b-valuation/)**: "Temporal is riding tailwinds from the pandemic, which supercharged cloud adoption as more companies and consumers used digital services. The company said it is seeing 25-to-50% month-over-month growth in adoption. Snap, Netflix, Instacart, Qualtrics, and others are using Temporal, which now joins an elite unicorn group of Seattle companies that have eclipsed the $1 billion valuation."
  - [**The Register**](https://www.theregister.com/2022/02/16/temporal_103m_funding/): "Temporal's technology is described as microservice orchestration platform that enables developers to build scalable applications without sacrificing productivity or reliability. It is already in use to solve state management challenges at companies such as Netflix, Snap, Box, Hashicorp, Coinbase, and others. Netflix has apparently chosen Temporal as the platform upon which to base its next-generation continuous integration and continuous delivery (CI/CD) developer service."
  - [**Silicon Angle**](https://siliconangle.com/2022/02/16/temporal-raises-103-million-accelerate-development-stateful-cloud-applications/): "The new cash infusion brings Temporal’s total funding to more than $128 million. The money will be used primarily to “reinvest in the community,” Zedlewski said. That includes more research and development of the open-source platform, additional language support, educational resources and expansion of the developer advocate network."
  - [**Daily UK**](https://dailyuknews.com/tech/temporal-raises-103m-in-series-b-funding/): "According to Temporal, one of the aspects of its system is that it abstracts the complexity of a distributed system. These are often a mixture of stateless services, databases, cron jobs, and queues, and as they scale, responding to multiple asynchronous events and tracking the state of everything becomes more and more challenging. Temporal effectively makes all these part of the platform and takes care of them itself."
  - [**Computer Weekly**](https://www.computerweekly.com/blog/CW-Developer-Network/Temporal-calls-time-on-cloud-app-state-management): "The fact that cloud applications are getting into a (right old) state over their state management capabilities due to the inherent complexity they are now being constructed with should come as no major surprise i.e. we know that the intertask dependency management, scheduling and concurrency logic responsibilities and requirements that exist in an application’s inputs across multiple related data flows is no point-and-click fix… which is why Temporal exists."
  - [**CIO Review**](https://www.cioreview.com/news/temporalio-raises-series-b-funding-to-expand-operations-nid-35112-cid-238.html): "Containerization and service-based architectures necessitate engineers managing state, a time-consuming and error-prone process that shifts the software development focus from business logic to brittle plumbing. Historically, developers relied on database transactions to preserve application consistency, but this is no longer an option for scaled cloud applications. As a result, they are compelled to improvise infrastructure like as queues, databases, CRON jobs, and more in order to provide some semblance of a coherent application experience. Temporal provides a uniform and unified backend for stateful applications, allowing developers to utilize their preferred languages, tool stacks, and deployment environment."

## Press Release

We also shared a press release with some never-before-seen quotes from Max and our new boardmember **Mike Volpi**, and **notable users like Snap, Netflix, Descript, Datadog, and Instacart**. The full text of the press release is [available here](/news/temporal-io-raises-usd100-million-series-b-company-valuation-passes-usd1-5).


saturn

We just announced our Series B fundraising, with a letter from Maxim, announcement from Brian Offutt at Index Ventures, a fun teaser video, and community Q&A!

Temporal Series B Press Roundup

Company

Temporal Team

temporal-team


After 493 commits, hundreds of user questions, and a year of active research and development, we are excited to announce the public beta of [our TypeScript SDK](https://temporal.io/ts)!

## Bottom Line Up Front

The Temporal TypeScript SDK lets you write highly scalable and reliable long-running workflows without being a distributed systems expert. It is designed with TypeScript-first developer experience in mind, but works equally well with JavaScript. 

- Docs: [https://temporal.io/ts](https://temporal.io/ts)
- [SDK source on GitHub](https://github.com/temporalio/sdk-typescript)  (give us a star!)

You can get started by: 

- running `npx @temporalio/create@latest` if you prefer developing locally with Docker, or 
- using our [prebuilt Gitpod environment](https://gitpod.io/#https://github.com/temporalio/samples-typescript/) for cloud development.

The minimum Node.js version is 14 but we recommend using 16.4.1 and up.

When you spin up a project, you will notice four dependencies you will use:

- `@temporalio/workflow` for Workflow APIs
- `@temporalio/activity` for Activity APIs
- `@temporalio/worker` for Worker APIs
- `@temporalio/client` for Client APIs

These represent the four core APIs you need to know to be productive with Temporal.

## Workflows and Workflow APIs

Workflows are async functions that can orchestrate Activities and access special Workflow APIs, subject to deterministic limitations. They start as "just functions":

```tsx
export async function exampleWorkflow(name: string) {
  return `Hello ${name}`;
}
```

To do anything interesting like calling activities or setting timers, you need to import our Workflow APIs as the `@temporalio/workflow` package.

```tsx
import { proxyActivities, sleep } from '@temporalio/workflow';
import type * as activities from './activities';

// explained later
const { greet } = proxyActivities<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export async function exampleWorkflow(name: string) {
  greet(`Hello ${name}, see you in a month`); // call activity
  sleep('30 days'); // set durable timer
  greet(`Hi again, ${name}!`);
}
```

The full Workflow and Workflow API docs are [here](https://docs.temporal.io/typescript/workflows).

## Activities

Activities are the only way to interact with external resources in Temporal, such as making an HTTP request or accessing the file system. They also start as "just functions":

```tsx
export async function greet(text: string): {
  console.log(text);
}
```

Activities run in the standard Node.js environment with none of the Workflow restrictions. For the most part this means you can safely copy-paste over existing Node.js code. The primary benefit is the robust system of retries and timeouts you get when doing so. When Activities are called inside Workflows, you can declaratively set retries and timeouts that set clear boundaries around Activity reliability:

```tsx
// Sample of typical options you can set
const { greet } = proxyActivities<typeof activities>({
  startToCloseTimeout: '30s', // recommended
  scheduleToCloseTimeout: '5m', // useful
  retry: {
    // default retry policy if not specified
    initialInterval: '1s',
    backoffCoefficient: 2,
    maximumAttempts: Infinity,
    maximumInterval: 100 * initialInterval,
    nonRetryableErrorTypes: [],
  },
});
```

The full Activity docs are [here](https://docs.temporal.io/typescript/activities) - there are a few more [Context utility](https://docs.temporal.io/typescript/activities#activity-context-utilities) functions exposed as `@temporalio/activity`.

## Workers

A Worker is a process that connects to the Temporal Server, polls for Tasks sent from Clients, and executes **[Workflows](https://docs.temporal.io/typescript/workflows)** and **[Activities](https://docs.temporal.io/typescript/activities)** in response. An application can have as many Worker Processes as needed to meet scalability and reliability requirements.

A standard Worker looks like this:

```tsx
import { Worker } from '@temporalio/worker';
import * as activities from './activities';

async function run() {
  const worker = await Worker.create({
    workflowsPath: require.resolve('./workflows'),
    activities,
    taskQueue: 'tutorial',
  });
  await worker.run();
}

run().catch((err) => {
  console.error(err);
  process.exit(1);
});
```

The full Worker docs are [here](https://docs.temporal.io/typescript/workers). In production, you will also want to [prebundle your Workflows](https://docs.temporal.io/typescript/production-deploy/#pre-build-code) and [configure connection strings and security options](https://docs.temporal.io/typescript/security#encryption-in-transit-with-mtls).

## Client

Workflow Clients are embedded in your application code (even including serverless Next.js API Routes), and connect to Temporal Server via gRPC. They are the only way to schedule new Workflow Executions with Temporal Server.

```tsx
import { WorkflowClient } from '@temporalio/client';
import { exampleWorkflow } from './workflows';

const client = new WorkflowClient();
const handle = await client.start(exampleWorkflow, {
  workflowId: 'business-meaningful-id',
  taskQueue: 'tutorial',
  args: ['foo', 'bar', 'baz'], // this is typechecked
});
```

The full Client docs are [here](https://docs.temporal.io/typescript/clients). 

## Next Steps

The 4 concepts of Workflow, Activity, Worker, and Client are a simple but powerful way to break down any distributed system design that you may need. 

- If you would like to run code and understand this yourself, check [our Hello World tutorial](https://learn.temporal.io/getting_started/typescript/hello_world_in_typescript/).
- If you prefer a long form, guided Workshop with Q&A, [join our upcoming Intro Workshop on Nov 30](https://lu.ma/temporalintro)!

> 2022 Edit - The workshop recording is [up on YouTube](https://www.youtube.com/watch?v=CeHSmv8oF_4)!!


shubham-dhage-C8YfO3YStVo-unsplash

After 493 commits, hundreds of user questions, and a year of active research and development, we are excited to announce the public beta of our Typescript SDK!

Introducing the Temporal TypeScript SDK

In the last year, Temporal has transformed from the wild dream of two Uber engineers, to a real business, community and product. In March 2020 there was no V1 release, no gRPC/PostgreSQL support, no authentication or authorization and Kafka was still a core dependency. Today things look a lot different. An amazing community formed around the project, we've validated our cloud strategy with paying customers and delivered a ton of critical features to the open source technology.

Every day Temporal feels more and more like its own entity, and less and less like a transformation of Cadence. This is not just ideological, at the code level there are constantly new differences introduced in both projects. For some critical changes it may be feasible to remain compatible, but in most cases it's just too much overhead. At a support level, the cost is also increasing. It's become harder and harder for our team to support Cadence users. When new employees join Temporal should they be expected to also ramp up on Cadence?

The most compelling factor is reliability. As a company and team we pride ourselves on providing one of the most reliable experiences available. The question that is now being asked internally is, "how we can provide this reliability for a project we have no control over?". As an example, we recently put out guidelines regarding how long we support older versions of Temporal. This is something we have no control over for Cadence and is impossible to enforce. This means that when Cadence users reach out they could be running the Cadence 1.0.0 or their own custom fork.

Cadence will always be an important part of our history. Today it is more than history, it requires time, energy and resources which we unfortunately cannot continue to spare. For this reason, we are announcing __end of life support for Cadence__ users. The final day of support will be the anniversary of Temporal's first production release September 29.

## What does this mean?

For the last year we have been happy to provide free support to Cadence users. After September 29th 2021, we will no longer be providing support for any version of Cadence. While we understand that it may be difficult for some Cadence users to find time to migrate, we feel that 1 year is a reasonable amount of time for us to provide support for a project which we are not the owners of.

## "Questions to get ahead of"

### Why not work with Cadence to create a common core?

While this is something which was initially considered, the pace and direction of the projects have diverged enough to raise serious doubts about its value. Cadence is a wonderful project with a great team but they serve the needs of Uber. At Temporal we are fully focused on the core technology and all of the ways we can improve it to make developers lives better. There are also already fundamental differences at a code level which prevent compatibility.

### What is the process of migrating to Temporal?

As of today there is no automatic process to migrate. The fundamental design of your application will generally remain the same, but specific API calls and values you provide them will need to be updated. We've created a page on our docs which details the majority of changes between Temporal and Cadence. If there is something missing from this list we would love to know: [https://docs.temporal.io/kb/cadence-to-temporal](https://docs.temporal.io/kb/cadence-to-temporal/)

We know migrating away from a critical dependency like Cadence can be daunting. We are also available to help with your specific migration process. Please feel free to post on our forums or contact us directly!

Is it possible to migrate live traffic from Cadence to Temporal?
At this time it is not possible to migrate live traffic from Cadence to Temporal. There are some unofficial efforts to build connectors or compatibility layers but nothing concrete as of today.

Will you still provide support for migration from Cadence?
Yes, we will always be happy to work with users who are interested in moving to Temporal. What will change is the level of specific support we provide for Cadence in that context.

### Will the Cadence team _?
We are not the Cadence team and unfortunately cannot speak to anything they will or will not do.

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).


clem-onojeghuo-T7gi cyrkdg-unsplash

For the last year we have been happy to provide free support to Cadence users. After September 29th 2021, we will no longer be providing support for any version of Cadence. 

Announcing EOL support for Cadence

Head of Product

Ryland Goldstein

ryland goldstein

__Latest Release at Time of Writing__: V1.2.1

Hey Temporal community, it's Friday again! It's been a long week with ahem a lot of other things going on in real life, but work has continued apace on Temporal.

## Update November 6, 2020

It's been a while since we published one of these updates, but in our defence, we were busy:

- Announcing Temporal v1.0, our first production-ready release
- Announcing our Seed and Series A rounds led by Amplify and Sequoia
- Shipping [our new Landing Page](https://temporal.io/) (ft. a well received [2 minute explainer video](https://www.youtube.com/watch?v=f-18XztyN6c)) and three case studies with Box, Checkr, and Coinbase (fun thing we noticed, they all have [blue logos](https://www.logomaker.com/blog/2017/09/27/blue-logos/))
- [PostgreSQL 9.6 support](https://github.com/temporalio/temporal/releases/tag/v1.2.1) (`v1.1.x` included schema changes for our MySQL and Cassandra support - see [release notes](https://github.com/temporalio/temporal/releases/tag/v1.1.1) for migration tools)

The team has grown some (including me!) and [we're absolutely hiring](https://www.temporal.io/careers)!

## Authentication is Coming

### TL;DR

We're working on Authentication for Temporal Web, and are looking for beta testers. Please get in touch at ryland@temporal.io if you're interested in helping to test!

### Context

Temporal is a highly critical system for many businesses, so security is paramount. Communication is already encrypted with [TLS](https://docs.temporal.io/references/configuration/#tls), and you can put Temporal behind a reverse proxy. However, one of our longest standing requests has been for an authentication/authorization layer for Temporal. This is what we are tackling first, as it is also necessary for the [upcoming Temporal Cloud](https://pages.temporal.io/cloud-early-access) service offering.

It's not ready for release yet, but we'd like to share how we're shipping this major feature. We basically followed the classic converge/diverge pattern:

![temporal-transparency-9-1](//images.ctfassets.net/0uuz8ydxyd9p/6QClhNHGdUWaIgDFjJmHCH/34a9fee3d2a2c7737ab6fa6c81332e98/temporal-transparency-9-1.png)

- __Diverge__:
  - __Collecting Requirements__: [Ryland](https://twitter.com/taillogs) had been meticulously collecting feedback from prospective customers for the past 6 months. Having this "CRM" (entirely done in Notion) ensured that we started with a strong idea of what our customers' most common requirements would be. For example, we realized that many companies use SAML and LDAP for authentication, but virtually everyone uses the OAuth/OpenID Connect (OIDC) open standard ([more info on OAuth and OIDC here](https://developer.okta.com/blog/2019/10/21/illustrated-guide-to-oauth-and-oidc)). We also wanted a solution that would work for both the self-hosted open-source version of Temporal, and for the coming Temporal Cloud offering.
  - __Comparable Research__: Sometimes customers don't tell you what they want. It can help to supplement customer research with comparable products. This helps surface ideas and perspectives we hadn't considered. We did a broad search of peer tools. This offered an even broader range of options, including the controversial "[The Prometheus project takes the stance that server side security features are outside its scope](https://www.robustperception.io/prometheus-security-authentication-authorization-and-encryption/)". Our search also showed that a surprising number of tools offered Certificate Authority auth. I was quite impressed by [the wide range of auth options offered by Grafana](https://grafana.com/docs/grafana/next/setup-grafana/configure-security/configure-authentication/).
- __Converge__:
  - Narrowing Scope: One of the most impactful things you can do to ship faster is to say no as much as possible during the design phase.
    - [Maxim](https://www.linkedin.com/in/fateev/) suggested offering authentication within the tctl CLI. However it would have involved crossing language and client-server boundaries that would have added undue complexity.
    - [Sergey](https://dev.to/temporalio/why-i-joined-temporal-19dg) had the retrospectively brilliant insight that most customers would demand OIDC Single Sign-On eventually. If we built our own username/password solution, it would be a lot of effort and it wouldn't be used by enterprises anyway. We decided that we would go all in on OIDC Single Sign-On.
    - Finally, we saw that Grafana had a wide range of OAuth options because they were incrementally adopted over the span of 4 years. We, as a greenfield solution, had the opportunity to leapfrog all that.
- __Researching Implementation__: Temporal Web is in Node.js, and the dominant authentication library has been [Passport.js](http://www.passportjs.org/) for years. After [confirming nothing had changed](https://twitter.com/swyx/status/1315754745412284416), we went with the obvious choice. In my research I had figured that we would pursue [Okta](http://www.passportjs.org/packages/passport-okta-oauth) and [Auth0](http://www.passportjs.org/packages/passport-auth0) integration first. But [Ruslan](https://www.linkedin.com/in/feedmeapples) found a [node-openid-client](https://github.com/panva/node-openid-client) that would fit our generic OAuth requirement found 🎉
- 
The process we envision will be as simple as providing your OAuth identity provider information in a config file (currently at `/server/config.yml`, both the location and the schema of this config are subject to change):

```
auth:
  enabled: true
  providers:
    # example provider config
      - label: 'googleoidc'
        type: oidc
        issuer: https://accounts.google.com
        client_id: xxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com
        client_secret: xxxxxxxxxxxxxxxxxxxxxxxx
        callback_base_uri: http://localhost:8088
```

In future we may support multiple auth providers, but we expect the vast majority of users to just use one.

We are currently in the implementation phase, and just did our first internal demo of the full authentication process this week.

![temporal-transparency-9-2](//images.ctfassets.net/0uuz8ydxyd9p/TUEek0UOG1bF7xZfY9lbr/84b6c21edc48b7b5b9eee7798bba26f5/temporal-transparency-9-2.gif)

It felt slightly surreal to be the first people to "log in to Temporal", though that is no exaggeration. A normal process might also have involved some UI design to ensure a delightful and accessible frontend experience. However we are holding out for a possible total design revamp sometime in the near future.

### Seeking Beta Testers!

If you have been waiting for this authentication feature, we'd love to send you an early preview of this for testing and feedback. Please email me at ryland@temporal.io!

## Conclusion

We are working hard to bring you authentication and other top feature requests you are asking for. If you'd like to receive updates on Temporal Cloud, do make sure to [join the waitlist](https://pages.temporal.io/cloud-early-access).

That's it from the Temporal side, have a great weekend everyone! As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).


mo-U3Kst7MY4Ok-unsplash

Hey Temporal community, it's Friday again! It's been a long week with ahem a lot of other things going on in real life, but work has continued apace on Temporal.

Temporal Transparency Update #9: Auth is Coming

__Latest Release at Time of Writing__: V1.1.0

__Update (10:36am PST) with current press__:

- [TechCrunch](https://techcrunch.com/2020/10/15/temporal-raises-18-75m-for-its-microservices-orchestration-platform/)
- [Business wire](https://www.businesswire.com/news/home/20201015005371/en/Temporal-Raises-18.75M-Series-A-Increases-Total-Raised-to-25.5M)
- [Geekwire](https://www.geekwire.com/2020/aws-microsoft-uber-engineering-vets-raise-20m-top-vcs-seattle-startup-temporal/)
- [SiliconAngle](https://siliconangle.com/2020/10/15/temporals-microservices-orchestrator-nets-startup-18-75m/)
- [Yahoo News](https://au.news.yahoo.com/temporal-raises-18-75m-series-160000059.html)
- [Mekhato](https://mekhato.com/aws-microsoft-uber-engineering-vets-raise-20m-from-top-vcs-for-seattle-startup-temporal/)
- [Biz Journals](https://www.bizjournals.com/seattle/news/2020/10/15/temporal-series-a-madrona-sequoia-seattle-tech.html)
- [Finsmes](https://www.finsmes.com/2020/10/temporal-raises-18-75m-in-series-a-funding.html)

## Announcement

Hey Temporal community, we have a big announcement for everyone.

10 years ago two engineers at AWS started working on a project that would turn into something way bigger than either could have expected. In the time since then, the underlying idea has been iterated on and refined into something that brings businesses tons of value and developers love. The next step of that journey starts today. Temporal is proud to announce it has received a 18.75M A round led by Sequoia Capital and a 6.75M Seed round led by Amplify Partners.

Before we talk about the future it's important to be grateful for the past. Without the support of every single one of you in the community creating a company or raising money would have never been possible. Very rarely will you find such a positive and intelligent group of people with a shared common goal but that's exactly what we have within the Temporal community. While Temporal is no longer just an open-source project, we are fundamentally dedicated to the open-source community who made all of this possible.

The funds will be primarily used for two efforts

1. Open-source features, fixes and community growth
2. Temporal cloud

We won't go into too many specifics of what's coming in open-source but new languages, databases and a real security story are definitely things to look out for. Outside of direct contributions, we also plan to hire a number of developer advocates and user-facing engineers to improve our support.

As some of you know, we are also working on a hosted version of Temporal. While we don't have a timeline we are evaluating interested parties as our initial design partners. These design partners will be the first cloud users and have official support (SLA backed) along with prioritized features and bug fixes. If this is something interesting to your or your company, please reach out to ryland@temporal.io.

Along with the announcement of our funding we wanted to talk about the three case studies that were published today. Temporal had the opportunity to work with the amazing engineering talent behind Box, Checkr and Coinbase to learn exactly what benefits Temporal brought their teams. These case studies are not only great validation for users considering Temporal but they were also a learning experience for us at Temporal:

1. Temporal, a central brain for Box
2. How Temporal simplified Checkr workflows
3. Reliable crypto transactions at Coinbase

Last but definitely not least, we are looking to hire a bunch of talented people in a variety of engineering and product roles. Our team is incredibly intelligent, progressive and friendly and we pay well and have great benefits. We work with the best companies in the world to solve the hardest technical challenges facing developers today. Due to the open-source nature of Temporal you will always have an opportunity to give back and directly interact with passionate users. Even if you're just curious to know what it's like to work here, please reach out and someone from the team will be very happy to chat.

[Work at Temporal](https://temporal.io/careers)

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

nkululeko-jonas-fSeKcdzeZTE-unsplash

Hey Temporal community, we have a big announcement for everyone.

Announcing our funding

__Latest Release at Time of Writing__: v1.0.0

Hey Temporal community, I hope you've got your socks on because this isn't a typical transparency report. I am extremely happy to announce that we have officially reached stability which means that Temporal V1 production release is now available.

This is a huge milestone for the project, community and Temporal as a business. Without our community, Temporal would have never existed. For all of you who have been waiting or blocked by this release, your patience is appreciated. This release served as a learning process for the Temporal team and we hope that it reflects in our future behavior.

![temporal-v1-announcement-1](//images.ctfassets.net/0uuz8ydxyd9p/1oWkkESRqnaf9jx8iAbAW4/914f51d2c834228fa9225346ea13065f/temporal-v1-announcement-1.png)

## What does this mean?

Temporal version 1 is available and ready for production consumption with the caveats covered in our last report (reiterated below). This also means that the system has entered a backwards compatibility era where there will be no more breaking API or schema changes for publicly facing APIs. Note that we will have a deprecation policy (which will be made public in the near future) so we can continue evolving and improving the product.

In this release we improved how shard IDs are hashed. This may cause an elevated rate of errors when upgrading cluster in-place from a previous release. To be 100% clear there is no potential for data loss and this should only happen once. The practical impact is slightly higher resource usage on your cluster until the upgrade is complete.

### What is not included in the release?

When scoping out the V1 stabilization work, we triaged features based on criticality and usage. During our triage we collected a list of features that we felt could be stabilized after the release and would not block the majority of users. We want to stress that these features are in no way "broken" and many users are already relying on them without issue. That being said, these features have not gone through the rigorous set of checks and validations that we require before deeming something "production ready". Moving forward, we will be referring to features that fall into this bucket as "experimental".

With this context, here are the features we consider experimental in this release:

- Archival
- Cross data center replication
- Batch operations (signal, terminate, cancel)
- Dynamic config
- Addition, removal and creation of searchable attributes with Elasticsearch

## What's next?

V1 is just the start of the Temporal story. Moving forward expect to see things like support for new languages, databases and security capabilities. We also plan to ramp up our engagement with users and have regular meetups, conferences and design sessions. On the business side, we are working on a cloud offering which will provide Temporal as a service. Aside from being a reasonably good way to support the company, we strongly believe that the requirement to run Temporal is one of the biggest barriers of adoption today. Having a cloud solution will make it much easier for new users to get started with Temporal and therefore enable us to continue growing this already great community. We still plan to release regular transparency updates but they may not come on such a strict schedule.

### Versioning

We recently made some changes to how our versioning will work moving forward.

- All validation logic is on the server. Client only sends headers. If header is missing assume that "client doesn't care" and no restriction is applied.
- Client sends to server following headers:
  - `client-name`: one of `temporal-go`, `temporal-java`, `temporal-cli`,
  - `client-version`: `1.0.0`,
  - `supported-server-version`s: `>=1.0.0 <2.0.0`.
- Server has `GetClusterInfo` API which returns its version and supported version ranges for every supported client.
- All old clients and servers are supported because they don't send these headers and fit into "I don't care" category. Moving forward we will be able to restrict old clients and old servers. (edited)

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

ricardo-gomez-angel-9AdeEdYB2yk-unsplash

Hey Temporal community, I hope you've got your socks on because this isn't a typical transparency report. 

Temporal V1 Announcement

__Latest Release at Time of Writing__: V0.30.0

Hey Temporal community, it's Friday! It's been a long week but the end is almost here, but not before we share some exciting updates about Temporal. We have been heads down and completely focused on stabilization and things are continuing to look positive.

## Update September, 18, 2020

### TL;DR;

- We are now code complete for stabilization effort
- All tests defined for V1 are now running in the pipeline
- Some parts of the system already stabilized
- Less and less bugs are being found and many identified bugs have been solved
- The following features will be considered experimental for the V1 release
  - Archival
  - Cross data center replication
  - Batch operations (signal, terminate, cancel)
  - Dynamic config
  - Addition, removal and creation of searchable attributes with Elasticsearch
- Confident in our original internal timeline for stabilization

### V1 Stabilization
We are officially code complete for our stabilization effort. This means that all tests which are required for us to be "stable" have been written and are now being run in some shape or form within the pipeline.

![temporal-transparency-8-1](//images.ctfassets.net/0uuz8ydxyd9p/1SOFClyEwGwcBXSoX9umt1/b0948f4df68ba96e9c87efd34b4e13c9/temporal-transparency-8-1.png)

Now that we have all the tests required for stabilization, the focus has now become continuously running those tests and identifying issues that pop up. When a new issue is discovered, we add it to a list and triage based on importance. Any issue that we consider even semi-critical is noted as a blocker and must be fixed before we consider that component stable. Through this process we've already successfully stabilized a few parts of the system. Over the next sprint we plan to continue with this approach and identify any remaining issues in non-stable components. I've linked some issues which have been identified and fixed below:

- [Reduce Maximum Page Size when retrieving Workflow Execution History](https://github.com/temporalio/temporal/pull/732)
- [Creating Workflows is unreliable when History Shards have recently moved around the cluster](https://github.com/temporalio/temporal/pull/734)
- [Simultaneous SignalWithStarts for the Same WF ID randomly returns an Internal Server Error](https://github.com/temporalio/temporal/pull/719)

If you're interested in learning more about how we approach stabilization, make sure to read the awesome post from Manu about our testing:

[https://docs.temporal.io/blog/temporal-deep-dive-stress-testing](https://docs.temporal.io/blog/temporal-deep-dive-stress-testing)

### Excluded components from stabilization

Temporal is a critical component for the majority of our users which means that we require a very high level of confidence for anything we classify as "production ready". For a feature or component to be considered production ready, there are a litany of scenarios, tests and validations which must be performed. Even for simple features this can be a significant undertaking as it often requires custom infrastructure and deployment strategies.

When scoping out the V1 stabilization work, we triaged features based on criticality and usage. During our triage we collected a list of features that we felt could be stabilized after the V1 release and would not block the majority of users. We want to stress that these features are in no way "broken" and many users are already relying on them without issue. That being said, these features have not gone through the rigorous set of checks and validations that we require before deeming something "production ready". Moving forward, we will be referring to features that fall into this bucket as "experimental".

With this context, here are the features we consider experimental in the V1 release:

- Archival
- Cross data center replication
- Batch operations (signal, terminate, cancel)
- Dynamic config
- Addition, removal and creation of searchable attributes with Elasticsearch

In general, experimental features will not stay experimental and eventually make their way into production. In the case of the V1 experimental features listed above, we intend to productionize all of them following the initial release. In some cases we may choose to not move a feature forward if demand/value seems low.

## Conclusion

We are feeling confident with our original internal timeline for V1 and believe we will reach it without delay. While we still aren't sharing any dates publicly, expect a stable release in the very near future. In the meantime we dropped a new version of server this week (V0.30.0) so please upgrade if possible. That's it from the Temporal side, have a great weekend everyone!

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

lubo-minar-qRGuuVOzsTc-unsplash

Hey Temporal community, it's Friday! It's been a long week but the end is almost here, but not before we share some exciting updates about Temporal. 

Temporal Transparency Update #8

__Latest Release at Time of Writing__: V0.29.0

Hey Temporal community, hope everyone is having a fantastic Friday. In our previous update we announced code completion for JavaSDK which also meant reaching the V1 code complete milestone. Now that we're code complete, this update will focus exclusively on the stabilization progress we made and what is on our plate looking forward.

Last week we had our second open office hours which was a huge success. The support from the community was humbling and there were some awesome questions about Temporal. We had some technical difficulties in the evening session, but they have been identified and will be avoided in the future. The session was recorded and will be available on YouTube shortly. Lastly, we plan to continue doing these sessions so if there are topics you would like to see covered in the future, please respond to this topic: [https://community.temporal.io/t/what-sessions-do-you-want-to-see-at-the-next-open-office-hours/243](https://community.temporal.io/t/what-sessions-do-you-want-to-see-at-the-next-open-office-hours/243)

## Update September, 4, 2020

### TL;DR;

- Deployment infrastructure continuously being improved
- Scale testing scenarios implementations nearly complete
- Initial work for fault-injection testing is done
- Still in discovery phase for issues caused by tests, number of discovered issues is decreasing
- Two weeks ago we reached code completion across our components and all engineering efforts shifted to stabilization. In the last update we laid out a framework for the stabilization effort that divided the work into 3 buckets: Deployment infrastructure, Code completion for tests, and Identifying problems discovered by tests.

### Deployment infrastructure

Over the last sprint we made a choice to slightly de-prioritize our deployment infrastructure work. We believe in building things that scale and avoiding unnecessary repetition but sometimes those goals aren't practical in the short term. It became clear that while improving our deployment infrastructure would have a positive impact on our long-term testing story, it also reduce our immediate velocity.

With that in mind, there was still some serious investment made into our deployment infrastructure over the last week. The team has been working on a dedicated Cassandra cluster and made significant progress. We also changed our Helm charts to isolate Cassandra nodes from Temporal server which leads to more realistic and practical perf testing.

### Code completion for tests

We are not yet code complete for our V1 stabilization tests but we have made serious progress in this area:

- Bench scenarios (non-failure) are almost entirely implemented and should be code complete soon. We plan on starting some long-running bench testing over the week which should give us key indicators about the systems performance.
- Initial failure scenarios are done but there is a considerable amount of outstanding work required to solidify the processes. The scenarios have not been integrated with Gremlin and are currently driven by bash and kubectl.
- We've validated a few scenarios which involve taking down different Temporal components during long running tests and then resuming them. Validation is achieved by tracking running workflows and ensuring they successfully finish.
- Backlog scenarios are still being developed.

### Identifying problems discovered by tests

The outcome of all testing and stabilization work is to identify and fix bugs that are lurking in the system. The good news is that the number of new bugs we are discovering has consistently decreased since we started our stabilization effort. While new bugs are still being found, there are less and less popping up each day. This is our key indicator of stabilization success and things are looking positive.

If you're interested in learning more about our stabilization effort and a deeper dive into the specific tests/scenarios, [Manu](https://github.com/temporalio/team) plans to publish a blog post in the near future covering this topic. We are still quite confident in our internal timeline and things look positive. Expect a Temporal release coming to a store near you in the not-so-distant future. In the meantime, have a great weekend (3 whole days for Americans) and stay safe out there!

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

Hey Temporal community, hope everyone is having a fantastic Friday. In our previous update we announced code completion for JavaSDK which also meant reaching the V1 code complete milestone.

Temporal Transparency Update #7

__Latest Release at Time of Writing__: V0.29.0

It has been two weeks since our last update which feels like a year in pandemic/startup time. We've been taking advantage of the time warping to make as much progress as possible on stabilization and the JavaSDK.

Before we get into the stabilization update there are a few other miscellaneous Temporal announcements. In the last month we've had some amazing additions to the Temporal team 🎊. Derek, Manu and Vitaly joined our engineering effort which had a very immediate and positive impact. I'd also like to give a shoutout to Karl who recently joined to lead our recruiting/hiring effort. Karl will enable us to continuously acquire great people as we scale. If you're ever curious about who's on our team, we regularly update our [GitHub page](https://github.com/temporalio/team).

As you may have heard, we are having our second open office hours on Aug 26. We are having the session twice (7am PST and 4:30pm PST) to accommodate users in different time zones. We would love to see you there.

## Update August, 24, 2020

### TL;DR;

- JavaSDK rewrite is complete and has been fully reviewed
- JavaSDK was released (compatible with server V0.29.0)
- We are now code complete
- The team is completely focused on stabilization, things look positive

### JavaSDK

We expected the JavaSDK to be finished by the code completion deadline (July 31) but the severity of bugs discovered convinced us a delay was the right choice. After further digging it became clear that a complete-rewrite of the underlying state machine backing the SDK was necessary. Once we reached this conclusion, Maxim started putting all his free cycles into refactoring the SDK to meet the quality bar we expect out of all software we release. After a ton of hard work Maxim was able to make the necessary changes and get the code out for review. As you might expect, Maxim codes pretty quickly so reviewing the changes was just as daunting as the work itself. Fortunately team came together and used shared knowledge to thoroughly review the changes without losing too much velocity.

The JavaSDK is now available and code complete. We appreciate everyones patience throughout the process.

### Stabilization

As we've ramped up our stabilization efforts, our perspective on the structure of the work has changed a bit. In the last update Samar described the distinct layers of our stabilization and explained where he expected most time to be spent:

- Deployment Infrastructure
- Scale Testing
- Failure Testing

As of today we are looking at the layers with a slightly different lens:

- Deployment Infrastructure
- Code completion for tests
- Identifying and fixing problems discovered by tests

While deployment infrastructure remains unchanged conceptually, we realized that there was more work than originally expected. The tooling we rely on came into question and we're actively in the process of evaluating our options. To give some more context, Alex was kind enough to write a summary:

> "Failure testing is important step of our stabilization process. We need to know how our cluster and workers operate under the pressure of different failures:

> - peak CPU and memory usage
- network failures
- other infrastructure failures

> We need to ensure that we don't lose any data and that workflows continue to execute when failures are mitigated. We're evaluating [Gremlin](https://www.gremlin.com/) to inject different failures as it is fairly easy to setup, has amazing UI and API access. It also support k8s out of the box which we use for our test environments. This decision is not carved in stone yet, but looks promising. In the near future we should get the initial results of running benchmark tests for the cluster under different failures." - Alex

For those who may have been curious about whether the JavaSDK delay would also delay testing on Java, worry not. Once we understood that the SDK needed serious refactoring, we immediately started working on the testing in parallel. This means that the JavaSDK work did not take resources/time away from the stabilization effort. The newly added tests for Java are especially exciting considering that these paths/scenarios have never been tested in the past, and are completely untested in Cadence.

We are very content with our progress over the last few weeks and still are confident in our initial scoping. We've gone "timeline-less" internally so no specifics, but things look positive. As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).


It has been two weeks since our last update which feels like a year in pandemic/startup time.

Temporal Transparency Update #6

__Latest Release at Time of Writing__: V0.28.0

This was a crazy week for us in a good way. We harnessed the momentum of our code completion efforts to stay extra focused on our next steps. In this update we're going to talk about the JavaSDK, stabilization, and more.

## Update August, 7, 2020

### TL;DR;

- JavaSDK bugs were addressed and a PR is out
- JavaSDK will be considered code complete after it has been reviewed
- [Once JavaSDK PR is in, we will be fully code complete](https://github.com/temporalio/java-sdk/pull/172)
- Almost all internal cycles have shifted to stabilization
- No timeline, but plan outlines what work is remaining
- We will continue updating regarding stabilization status until we reach the production V1 release

### JavaSDK

As we mentioned last week, there were some bugs in the JavaSDK that only Maxim had the domain understanding to address efficiently. Maxim worked even harder than usual this week to ensure he could fix these issues. In the process of fixing the original problems it became clear that a massive refactor was needed. That refactoring work was completed in the last few days and is now in the review stage. If anyone is interested in the PR and/or wants to give feedback, it's available here:

[https://github.com/temporalio/java-sdk/pull/172](https://github.com/temporalio/java-sdk/pull/172)

We plan to update the community once this PR has been merged and the SDK is available. Closing this PR is also the last component required for us to be code complete across all services and components.

### Stabilization

*Samar was kind enough to guest write this section and share our perspective*

It was an amazing effort by the team to finish all tasks for us to hit code complete for both Temporal Server and Go SDK last week. This brings clarity to our future updates and greatly simplifies adopting new releases from Temporal. Here is what users can expect from future releases:

### Backwards Compatibility

We are not planning any breaking API changes for Go SDK or service gRPC definition. Additionally we are going to maintain schema compatibility for Cassandra and MySQL. This means users should be able to adopt future releases during stabilization, without making any changes on their end.

### Stability

Now entire team is focused on hardening the system. During this phase we are making significant investments in the following areas:

1. __Deployment Infrastructure__
We have made a requirement to automate every new scenario that we add during stabilization. This means we want to have our release process completely automated. We are using Concourse to create fully automated CI/CD pipelines and have already made pretty great progress.

4. __Scale Testing__
This is where we really push the system hard in various dimensions and make sure it is able to keep up with the load gracefully.

7. __Failure Testing__
One of the most important areas during stabilization is making sure Temporal server can gracefully recover from various failure situations. Temporal is used in the critical path for many applications at various companies. It is super critical for us to make sure system is resilient to different kind of failures and workflows are able to make forward progress in the presence of failures.

### Quality

As I mentioned in my last post, quality is super critical for us and we take it very seriously. We now have a plan for stabilization in place and will be sharing our progress regularly with the community.

### Moving Forward

This is a great top-down/idealogical understanding of our stabilization process but some of you may want something a bit more practical. On that note, here are the epics we have created for V1 stabilization:

![temporal-transparency-5-1](//images.ctfassets.net/0uuz8ydxyd9p/1or3X5CuZ6Umyx6MyDRgXl/e4bd9210196e3c46c69ae1f3b23aea8a/temporal-transparency-5-1.png)

Outside of actively tracking the status of these epics and their underlying tasks, the pipeline is a great way to visualize the progress we're making, as each green item represents a successful check/test:

![temporal-transparency-5-2](//images.ctfassets.net/0uuz8ydxyd9p/3Olae4rmaqCbcXWQhzS2By/b1f4ebdec1cb02fc0bb38e49a400beb0/temporal-transparency-5-2.png)

The team is completely heads down and focused on stabilization efforts so we're hoping things move quickly without hiccups. I do want to reiterate that while we do not expect to find any critical bugs, there is a chance that a critical bug could require breaking schema changes (not API or code). Keep in mind it would require a bug of quite high severity to require changes to the underlying schema. That being said, we strongly recommend __not__ using the current release in a production environment.

As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

This was a crazy week for us in a good way. We harnessed the momentum of our code completion efforts to stay extra focused on our next steps. In this update we're going to talk about the JavaSDK, stabilization, and more.

Temporal Transparency Update #5

Today is an exciting day for us! Temporal is releasing its newest version, v0.28.0, bringing us one step closer to a stable production ready release. We want to thank all of the users who have helped us iterate and move the product forward.

This changelog includes all of the changes since Temporal forked from Cadence, and should help users who are interested in upgrading.

## What has changed?

- __Cadence Oct 2019 → Temporal v0.28.0 Alpha__: The software version has bumped.
- __ Thrift/TChannel → [Protobuf/gRPC](https://grpc.io/)__ ⚡ :
  - Server Thrift API → Protobuf [API](https://github.com/temporalio/api). Go import path is `go.temporal.io/api`.
  - All communication over the wire can be encrypted via [TLS](https://docs.temporal.io/references/configuration/#tls). Note: Support for TLS in `tctl` and `temporal-web` is still in-progress.
  - Thrift errors have been converted to custom service errors backed by standard [gRPC error codes](https://pkg.go.dev/google.golang.org/grpc/codes).
  - Errors are serialized using the Protobuf type `Failure`. They can now be chained together and passed across different SDKs in different languages.
  - All payloads (Workflow input, Activity input, etc...) sent to Temporal now have headers and data fields.
  - Standard [gRPC health service](https://github.com/grpc/grpc/blob/master/doc/health-checking.md) is used for health checks.
  - Standard Protobuf types are used for [time](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#timestamp) and [duration](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration).
  - Uber YARPC library has been removed.
- __Helm charts__ ☸️ : [Deploy the Temporal server to a Kubernetes Cluster](https://github.com/temporalio/helm-charts).
- __Entity renames__ 🏷️ :
  - `Decision` → `Command`.
  - `DecisionTask` → `WorkflowTask`.
  - `Decider` → `Workflow`.
  - `Domain` → `Namespace`.
  - `NamespaceStatus` → `NamespaceState`.
  - `TaskList` → `TaskQueue`.
  - `ArchivalStatus` → `ArchivalState`.
- __Import path rename__ 📦 : `go.uber.org/cadence` → `go.temporal.io/sdk`.
- __Workflow timeout refactors__ ⌛:
  - Workflow timeouts are optional.
  - Attempt counters start at 1.
  - Workflow Executions have 3 timeouts available:
  - Renamed:`ExecutionStartToCloseTimeout` → `WorkflowRunTimeout`.
  - W`orkflowExecutionTimeout` is new. It limits the total Workflow execution time including retries and continue-as-new. It also enables limiting the total time of a cron job. The default is 10 years. `WorkflowRunTimeout` defaults to the value of `WorkflowExecutionTimeout`.
  - Renamed:`DecisionTaskStartToCloseTimeout` → `WorkflowTaskTimeout`. Defaults to 10 seconds.
- __Workflow retry refactors__ 🔁 :
  -  `ExpirationInterval` has been removed from `RetryPolicy`. Instead, `WorkflowExecutionTimeout` is used to stop retries for Workflows.
  -  Attempt counters start at 1.
- __Activity retry refactors__ 🔁 :
  - Temporal includes default RetryOptions for Activities.
    - `initialInterval` = 1 second.
    - `maximumInterval` = 100 * initialInterval.
    - `backoffCoefficient` = 2.
  - To disable Activity retries, configure Activities with `RetryOptions` that set `maximumAttempts` to 1.
  - `ScheduleToClose` is used to stop retries for Activities.
- __CLI updates__ 🧰 :
  - New admin commands:
    - List namespaces ([#463](https://github.com/temporalio/temporal/pull/463)): `./tctl admin namespace list`.
    - Describe Shard ([#370](https://github.com/temporalio/temporal/pull/370)): `./tctl admin shard describe --shard_id ... / d -sid`.
    - List Tasks ([#429](https://github.com/temporalio/temporal/pull/429)/[#433](https://github.com/temporalio/temporal/pull/433)): `./tctl admin shard list_tasks`.
    - Describe Task ([#408](https://github.com/temporalio/temporal/pull/408), [#416](https://github.com/temporalio/temporal/pull/416), [#412](https://github.com/temporalio/temporal/pull/412)): `./tctl admin shard describe_task --task_type [timer, replication, transfer] ... / dt`.
    - List Cluster memberships([#423](https://github.com/temporalio/temporal/pull/423/files)): `./tctl admin membership list_db`.
    - List Ringpop members ([#426](https://github.com/temporalio/temporal/pull/426)): `./tctl admin membership list_gossip`.
    - List Replication DLQ Tasks ([#456](https://github.com/temporalio/temporal/pull/456)): `./tctl admin kafka list_dlq`.
  - Admin Command improvements:
    - Filter Tasks from TaskQueue based on Workflow and run Ids ([#462](https://github.com/temporalio/temporal/pull/462)).
    - Consistent CLI admin command names ([#427](https://github.com/temporalio/temporal/pull/427)).
    - Enum parameter flags changed from int to string ([#445](https://github.com/temporalio/temporal/pull/445), [#447](https://github.com/temporalio/temporal/pull/447)).
    - Support `table-view` for list commands ([#444](https://github.com/temporalio/temporal/pull/444)).
- __Simplified SQL Schemas__ ➰ : Schemas are now less complex.
- __All Queries are strongly consistent__ 🔎 : The actual current state is always returned.
- __SDKs__ 🔌 : Significantly improved experience for both Java SDK and Go SDK.
- __When using Docker__ 🐳 :
  - `BroadcastAddress` can be configured via the `TEMPORAL_BROADCAST_ADDRESS` environment variable.
  - `MYSQL_TX_ISOLATION_COMPAT` environment variable can be set as `true` in order to support setting up schemas with pre-5.7.20 MySQL installations.
  - Getting started experience has been simplified to have Docker pre baked with 'default' namespace.
- __Other minor changes__ 🔹 :
  - Pass 127.0.0.1 explicitly to Cassandra in docker dependency ([#540](https://github.com/temporalio/temporal/pull/540)).
  - Remove statsd from docker-compose files ([#536](https://github.com/temporalio/temporal/pull/536)).
  - Expose Cassandra and serial consistency settings in configuration ([#533](https://github.com/temporalio/temporal/pull/533)).
  - Adopt [Google api-linter](https://linter.aip.dev/) and [Buf](https://buf.build/) ([#526](https://github.com/temporalio/temporal/pull/526)).
  - Support dynamic cluster IP addresses in failure scenarios ([#495](https://github.com/temporalio/temporal/pull/495)).
  - Save last `RetryStatus` for retryable failures ([#432](https://github.com/temporalio/temporal/pull/432)).

## Docker images (use tag 0.28.0)

- [Server](https://hub.docker.com/repository/docker/temporalio/server)
- [Server With Auto Setup](https://hub.docker.com/repository/docker/temporalio/auto-setup)
- [tctl (CLI)](https://hub.docker.com/repository/docker/temporalio/tctl)
- [Admin-Tools](https://hub.docker.com/repository/docker/temporalio/admin-tools)

Today is an exciting day for us! Temporal is releasing its newest version, v0.28.0, bringing us one step closer to a stable production ready release. 

Temporal v0.28.0 changelog

SDE Technical Writer

Cully Wakelin

cully wakelin

__Latest Release at Time of Writing__: V0.28.0

It's been a productive week for Temporal and I hope the same is true for all of you in the community. I'm excited to share the progress we've made towards V1.

## Update July, 31, 2020

### TL;DR;

- We are now code complete for Temporal server and GoSDK.
- There are some unexpected blockers that will delay JavaSDK until next week.
- No more breaking API /code changes for the server or GoSDK. All major changes will be backwards compatible moving forward.
- We will eventually release a deprecation schedule/agenda for features
- All focus has now been shifted to stabilization and JavaSDK
- Only once we're confident in V1 stability will we encourage production usage
- After V1 is stable, no more breaking schema changes
- THIS IS NOT A PRODUCTION RELEASE!

We are now code complete for Temporal server and GoSDK. If you're interested in what has changed since Temporal was forked from Cadence, our awesome new technical writer/information architect Cully prepared a [changelog](https://docs.temporal.io/blog/temporal-v0.28.0-changelog/).

We were not able to get the final JavaSDK changes in before code completion, so we've made the decision to delay this specific work until next week. While this isn't optimal, we assumed that users would appreciate having access to the major components today as opposed to blocking everything until the JavaSDK is ready. Now that we are code complete for Temporal server and GoSDK, it means that there will be no more backwards incompatible API or code changes for those components moving forward. Any drastic changes made in the future will be made in a compatible way and put behind a deprecation schedule. Here is the state of our pipeline:

![transparency-update-4-1](//images.ctfassets.net/0uuz8ydxyd9p/jvPmxXPtQ66h3tliqQzDl/69b3161f231b347e280a9cccb87c9dea/transparency-update-4-1.png)

With the majority of changes for V1 in, we have shifted all of our focus onto stabilization. We have been ramping up our stabilization process in parallel to our code completion efforts, so we're already moving with significant momentum. As stated in previous updates, we do not feel comfortable giving out a hard date for stabilization. This is not because we lack confidence in our estimates or don't understand the scope of work. This choice was made because reliability is foundational for our product and business, and we will always opt for reliability over velocity. While we do not expect to encounter any critical bugs moving forward, should we discover them, we won't release until they are fixed. If this happens, there is a small chance that we will have to make breaking schema changes before the official V1 release. Again, this is not expected but we want to make it 100% clear that it's not impossible. We will announce our production ready V1 release when stabilization is complete. After the V1 production release, there will be no more breaking schema changes.

Next Friday we will share our testing and validation plan for V1. The plan should make it much clearer what we inexpect from the stabilization effort. We will continue posting weekly stabilization updates until we reach a production V1 release. Post-V1 we will continue releasing transparency updates, but will be moving to a bi-weekly schedule.

Everyone in the team put in a ton of extra effort over the last few weeks so we could meet the deadline. I'm personally so grateful to be working with such a dedicated and intelligent group. As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

shubham-dhage-8ZGZlksF8mo-unsplash

It's been a productive week for Temporal and I hope the same is true for all of you in the community. I'm excited to share the progress we've made towards V1.

Temporal Transparency Update #4

__Latest Release at Time of Writing__: V0.27.0

Hope everyone had a productive and enjoyable week! I'm here to share our third update for V1 code completion.

## Update July, 24, 2020

### TL;DR;

- Code complete date remains unchanged, July 31, 2020
- Massive progress on remaining code completion items, 50% of tasks were completed
- Based on this weeks progress, it's unlikely we will need to cut tasks to make the deadline
- Team members who finish their work for code completion will begin immediately working on stabilization

Based on the awesome effort from the team we were able to finish ~50% of the remaining items for code completion during the last week:

![transparency-update-3-1](//images.ctfassets.net/0uuz8ydxyd9p/55z5OkD0wkrTXPz3wN3DUv/df3908f0f902b026bfd333ad2074c68d/transparency-update-3-1.png)

We're in the final stretch and things are looking very positive. All remaining items required for code completion are shown in the image below:

![transparency-update-3-2](//images.ctfassets.net/0uuz8ydxyd9p/449QWQVLgqiwKPWZFMK9P5/b8774e3e1925fb676a8115e04627436f/transparency-update-3-2.png)

Based on the progress made this week, we are quite confident that we will meet the initial date we defined for code completion (July 31, 2020). The remaining work is relatively well scoped and understood so there shouldn't be any showstoppers that pop up (fingers crossed). As team resources free up internally over the next week all focus will be shifted to stabilization.

Things in the world have been a bit rough lately so hopefully this update comes as a bit of good news. As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

Hope everyone had a productive and enjoyable week! I'm here to share our third update for V1 code completion.

Temporal Transparency Update #3

__Latest Release at Time of Writing__: V0.27.0

Hope everyone is having a great Friday. I'm happy to share our second V1 status update as part of our continued effort to be more transparent.

## Update July, 17, 2020

### TL;DR;

- Code complete date remains unchanged, July 31, 2020
- New tasks were generated from existing GitHub issues (check those out below)
  - [https://github.com/temporalio/temporal/milestone/2](https://github.com/temporalio/temporal/milestone/2)
  - [https://github.com/temporalio/go-sdk/milestone/1](https://github.com/temporalio/go-sdk/milestone/1)
- Many tasks are in progress and things should start clearing up early next week
- We have begun further prioritizing tasks so we can easily cut less important work as we near code completion

We're continuing to dedicate the majority of our time and energy to V1 code completion. Here are the items which we handled since the last update:

![temporal-transparency-update-2-1](//images.ctfassets.net/0uuz8ydxyd9p/4Sgnf2eRhtEuBXdsp4r5Hj/6faf5cbe4864c5d8afd23f64ca836d26/temporal-transparency-update-2-1.png)

While we did make serious progress on our previously defined tasks, we also ended up adding a considerable number of new items:

![temporal-transparency-update-2-2](//images.ctfassets.net/0uuz8ydxyd9p/7yhYO1HyNzzIFTZfYeIVkN/ef66bf4db5f8b3812f5ded2c29296f65/temporal-transparency-update-2-2.png)

New items are the result of us triaging open issues in our public GitHub repos earlier in the week. While we didn't expect to have any additional items added before code completion, we're happy that they are now being tracked. To make it easier to track publicly, we've created a few GitHub project milestones with all of the newly discovered work:

- [https://github.com/temporalio/temporal/milestone/2](https://github.com/temporalio/temporal/milestone/2)
- [https://github.com/temporalio/go-sdk/milestone/1](https://github.com/temporalio/go-sdk/milestone/1)

We are very set on sticking with the date we initially defined for code completion (July 31, 2020). This means we will realistically end up cutting many items as we get closer to the deadline. Samar and I have begun to prioritize the remaining work, so we can cut intelligently when the time comes. Our belief is that a large number of in-progress items will be completed this week, which should result in a much more appealing status update next week.

I hope this sheds some light on what is going on internally. As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

praewthida-k-5Ui5glVjUAQ-unsplash

Hope everyone is having a great Friday. I'm happy to share our second V1 status update as part of our continued effort to be more transparent.

Temporal Transparency Update #2

__Latest Release at Time of Writing__: V0.26.0

We recently announced that there would be some changes to our V1 release timeline. While we obviously prefer to deliver on time, this situation indicated we should be more concerned with our transparency than our velocity. We believe that life is full of surprises and sometimes you can't prevent delays, but you can always have open and direct communication channels. Moving forward our goal is to be consistently open and transparent, especially when we're working on things that are in our users critical path. As a first step, we plan to release regular updates (like this one) that provide insight into what the team is working on and what hasn't been worked on yet.

## Update July, 10, 2020

### TL;DR;

- July 31, 2020 is our concrete date for being code complete.
- After July 31 we will immediately begin stabilization efforts.
- There is no guaranteed date for stabilization yet.
- As we near code completion, we will release our stabilization tasks.

The team is working hard on the remaining items needed for code completion. I've worked with Max and Samar to ensure that our estimates reflect the remaining work much more accurately than before. This accuracy greatly improves our confidence, enough that we feel comfortable giving a hard date for code completion of July 31. This means that after July 31 we do not intend to make any breaking API or interface changes. While we do not expect to encounter critical bugs which would require schemas to change, there will always be a possibility until we've reached a stable release. I've included a picture (below) which represents all the remaining tasks needed to reach code completion as of Today (July 10).

![temporal-transparency-update-1](//images.ctfassets.net/0uuz8ydxyd9p/4447TPdWAgiQUvZNx4SMUT/fbd9232644a2c8dbca62b9035876c8da/temporal-transparency-update-1.png)

In parallel to the code completion effort, we're also investing a lot of energy into understanding the scope of work needed for stabilization. We can't give a specific date yet for the stable release as there is still a chance that critical bugs will be discovered. Reliability is our #1 concern and therefore we will not release until all critical bugs are fixed. Although we can't provide a solidified timeline, we can be open and transparent about what we're working on and what we have left to work on. As we near code completion later this month, I will begin sharing updates about the stabilization, just like I did with code completion tasks pictured above. Until then, I'll occasionally share the status of our existing CI/CD pipeline (picture below):

![temporal-transparency-update-2](//images.ctfassets.net/0uuz8ydxyd9p/2tRPmVx6H3cVvAQ8n8mMdR/0502b7ee496b11388d8ebdf5ea5d31c2/temporal-transparency-update-2.png)

I hope that this provides insight into what we've been focused on recently and what we'll be focused on next. As always, feel free to reach out with questions, comments or critical feedback via <a href="mailto:community@temporal.io">email</a>, [Slack](https://temporalio.slack.com) or our [community forum](https://community.temporal.io/).

We believe that life is full of surprises and sometimes you can't prevent delays, but you can always have open and direct communication channels. Read our update here.