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

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

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](/press/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

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

CEO and Co-Founder

Maxim Fateev

maxim fateev


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/cadence-to-temporal](https://docs.temporal.io/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 [change log](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/).