## Overview
So you want to create a new world class API that differentiates you from your competitors.  I hope that I can shed a bit of light on the topic.  But first, let's take a step back.  An API is just a piece of the puzzle it's a definition of the contract between yourself and your integrators but there's more than just the contract, there's documentation, sample code, client libraries, tools and more that can help differentiate your product.  I like to think of it as an end to end integration developer experience.

Let's get into it and discuss all of the attributes of a great developer experience, API design and define a framework for creating APIs.  This series of blog posts will focus on web APIs.  Building a local API like interfacing with hardware or hooks for a platform framework have a similar but separate set of considerations.  Lets start with what makes a great developer experience to define our goal then jump into the framework.  

So what is a great developer experience?  I think the easiest way to describe many of the attributes of a great experince is with a few examples.  My personal gold standards(for different reasons) are Stripe, MDN, and Flutter.

## Developer Experience Examples

### Stripe

Stripe has democratized accepting card payments online.  While on the surface card payments may seem simple, enabling it can actually be incredibly complex.  There's a number of rules around securing card data, what can be stored where.  A number of card networks beyond the big 4.  There's both customer and merchant fraud and chargebacks and many more complexities.  Stripe has simplifed that mostly down to copy and paste snippets.

```js
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        // Provide the exact Price ID (for example, pr_1234) of the product you want to sell
        price: '{{PRICE_ID}}',
        quantity: 1,
      },
    ],
    mode: 'payment',
    success_url: `${YOUR_DOMAIN}/success.html`,
    cancel_url: `${YOUR_DOMAIN}/cancel.html`,
  });

  res.redirect(303, session.url);
```

#### 1. *A great developer experience(and product) starts with simplifing something complex.*
<br />

In addition Stripe innovated in documentation creating the 3 column layout.  They understood the pain points of the existing documentation experience and improved upon it eg examples of requests in reference documentation instead of just a description of the field.  Stripe docs are a night and day difference from my starting documentation format [Javadocs](https://javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/module-summary.html) (I still &lt;3 GSON, worked with Joel and Inderjeet while in the payments org at Google).      

<div className="Image__Medium">
  <Image
    src="/images/stripe-reference-docs.png"
    alt="Stripes 3 column layout"
  />
  <figcaption>Stripe's 3 column layout</figcaption>
</div>

#### 2. *Understanding developer needs and pain points and making it simple to understand the product.* 
<br />
The last major Stripe superlative for me is they have great tooling for simulation and testing.  As an integrator you can test various card types, trigger specific flows, and test all of the edge cases that your implementation needs to handle.  Imagine how painful it would be if you couldn't test some functionality of your product until you saw the case occur in production.  

#### 3. *Provides testing and simulation tools to trigger all relevant use cases and flows.* 
<br />

### Mozilla
Mozilla is my defacto reference for web APIs.  Their breadth and depth of web documentation in my mind is unparalleled.  In my experience with vanilla web developement I don't think that there's ever been a case where I couldn't find reference documentation or a guide on MDN.  And many of the guides include multiple cases and related functionality. It means that I don't have to waste time looking through sample code, Stack Overflow or Reddit to understand how to do use something.  

#### 4. *High percentage of well organized documentation coverage for APIs* 
<br />
And each of the examples or snippets of code work or at least state compatability with browser version.  I don't have to deal with figuring out if it's an issue with my configuration or the API.

<div className="Image__Medium">
  <Image
    src="/images/mdn.png"
    alt="MDN"
  />
  <figcaption>MDN Async Documentation</figcaption>
</div>

#### 5. *Documentation is maintained and up to date with minimal errors on examples* 
<br />

### Flutter
Flutter is my dream experience as a developer.  It's meant to be a write once compile to web, Android, iOS platform.  In the past, I feel like getting setup correct was a large hurdle, setting up the Android SDK, defining run targets, defining debug config etc.  Flutter has a helper to check your system config and plugins for the most popular IDEs.  This means that I can easily get my config right and focus on coding and debugging.  Anecdotally I tried to first build this blog on Gatsby.  Maybe I'm a newb but I could not for the life of me figure out how to configure debugging for Gatsby + Typescript.  The inability to debug forced me to rewrite in Next.js where the VScode source maps worked correctly.

#### 7. *Thoughtful, integrated experience and tooling to simplify debugging*
<br />

There are some other aspects of a developer experience that given the right circumstances may be important as well such as:
- Thriving communities can supplement insufficient documentation and drive viral adoption
- Client libraries are usually expected and can simplify implementation vs autogenerating from schema

## Framework
Awesome, now we have an idea of where we want the developer experience to go let's break down the components of an API / Developer Experience and figure out what questions we need to answer to get there.  I would define a component as a touch point for a customer.  Examples of components could be the API itself, client libraries, documentation or webhooks.  All of the pieces of an API that as a customer I would interact with as part of integration (or building / maintaining the API).

I'll start with a high level overview of components then dig into each component and considerations for components in subsequent blog posts along with a end to end practical example.

### Schema Definition
What are some of the best practices for structuring an API?  How do you define an API?  There are a few schema defination languages (SDL) like OpenAPI, GraphQl, GRPC, JsonRPC, json:api.  A SDL and it's associated tooling can have huge impacts on your documentation, client libraries, engineering experience.  How do you govern API design across an engineering org.

#### Flexibility vs Simplicity
What stage is your company and what do you want to optimize for?  Flexibility means using the API like lego building blocks.  But accomplishing a task may take more steps.  Simplicity means focuing the API and minimizing steps for a task.  Which direction should you skew and when?

#### Authentication & Permissions
Authentication is usually dependent on how you expect your customer to use your API.  It could be a public key, jwt, bearer token, or basic auth user and password.  Can a customer create multiple scoped API keys?  For example, can an API key access all resources?  Can it read and write or only read?  How do you handle permissioning for API Keys?

#### Versioning / Interoperability / Deprecation
You will likely need to iterate on your API as you better understand your customer needs and develop your product.  There are a few different strategies for handling breaking changes and deprecating old versions.  Do you want to optimize for minimizing integrator pain or eng team maintenance pain?

#### Idempotency, Retries, Rate Limits & Timeouts
Does your API need some sort of recovery mechanism if the network does to prevent duplicate requests?  What happens when you retry the same request? 

#### Governance
How do you get multiple eng teams to produce an API surface that feels like a single product and not N different products?  Do you need a specific release process?

### Webhooks
How can you notify the customer's services when an event doesn't initiate from one of their requests?  How does the customer subscribe to those events.  How is security handled?  What if their services are down when you want to try to notify them?

### Onboarding
How does a customer sign up for your service and get API keys?  What are the steps to get access to production?

### Documentation & Samples
How do you educate your integrators on the integration process?  What type of content do you need to provide?  Who's writing the documentation?  How much content do you need?

### Environments, Testing, Debugging & Tooling
Should you offer a sandbox? How do your customers test their implementation?  If an error occurs how do they understand and fix the issue?  Would a VScode extension simplify the developer experience?

### Client Libraries
Do you provide client libraries or does your customer generate client libs from the schema?  What languages should you support?  

### Monitoring & Alerts
What should you track to be aware of the health of your API?  What is downtime?  Is it latency > a limit?  Is it 500 responses?  Does a single 500 count as down time?  What about intermitten 500 responses?  How can you be notified of these issues?

## Next Steps
In this series of posts, I'll dig into each of these components and try to provide insight into each of these questions.


Building an API

I know I said that I'd fix mobile for the blog and Analytics says that I should.

<div className="Image__XSmall">
  <Image
    src="/images/analytics_screen.png"
    alt="analytics of viewers"
  />
</div>

I also said that I would write a blog post about creating APIs.  And, yeah I haven't gotten to that either.  I've just been so engrossed in learning more about ML.

In this post I want to share my learnings from trial and errors playing with ML.  I dabbled a bit in college but it's mostly a new subject matter for me.  There's so much to learn that it can be hard to focus and prioritize.  I'm trying to attack from both sides.

- Technical understanding of how machine learning works starting from gradient descent and building up through CNN / RNN to transformers 
- Running models on my machine to and seeing firsthand what they're capable of and understanding the toolchain / interaction pattern

My hypothesis is that by seeing the end product, I'll better understand how the things I'm learning bottom up can fit in the big picture.

<Blockquote>Also there's just something super cool about seeing it run on your machine instead of on OpenAI or Google's nebulous cloud.</Blockquote>

I'm still naive in the space but every additional piece of understanding gives me more hope that I'll be able to modify these models for my own ideas and products. 

## The Wow
Get hyped!  ML is more accessible than most people think.  I have a 2 year old laptop with a 3080 and I can run a 7b parameter LLM or Stable Diffusion model locally in a few steps.  Fun fact, the header image was generated locally from Stable Diffusion 2.1 but this post was written with out the help of any chat bots.

The following instructions are focused on Nvidia GPUs since that's what I have, but there's also a section at the [bottom](#CPU-LLMs) on CPU LLMs so you can run it on your Mac or non Nvidia devices.

> I shifted from Windows WSL2 to Ubuntu as I was getting some download errors that I just couldn't figure out.  You can try it in Windows but I kept receiving the following error after downloading a 10gb file and had to restart the download every retry.
> I think this error was actually a red herring and the issue was caused by insufficient VRAM but I didn't have the expertise to debug further beyond running locally instead of a container.

```bash
RuntimeError: An error occurred while downloading using hf_transfer. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for better error handling.
```


### Prerequisites

You'll need to have:

- [Docker](https://docs.docker.com/engine/install/).
- Latest Nvidia drivers

```bash
sudo apt install nvidia-driver-535
```

- [Nvidia Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
- [Request access](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf) to Facebook's Llama 2 model
- [HuggingFace token](https://huggingface.co/settings/tokens)
> One thing I haven't figured out is how to get docker access to my GPU without root.  You may see some instructions about starting docker w/o sudo on the web but I never figured out how to get those instructions to work.

### Running The LLM 
The two most popular open source LLMs are [Facebooks Llama](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf) and [TII's Falcon](https://huggingface.co/tiiuae/falcon-7b).  I tested both and my personal preference is Llama so that'll be the first set of instructions.

This is my own version of Hugging Face's [text generation inference](https://github.com/huggingface/text-generation-inference) instructions, more detail on the tool can be found in the repo.

#### Llama 2

```bash
model=meta-llama/Llama-2-7b-chat-hf 
volume=$PWD # share a volume with the Docker container to avoid downloading weights every run
token={HUGGING_FACE_HUB_TOKEN}

sudo docker run -e HUGGING_FACE_HUB_TOKEN=$token --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:1.0.3 --model-id $model --quantize bitsandbytes
```

These commands set some environment variables then tell docker to load the image and run the model.

- From what I understand the Llama 2 chat hf model is fine tuned for chat and hf stands for human feedback?  
- Quantize bits and bytes gets the model to fit in around 14GB of VRAM.  Otherwise I was getting errors during memory allocation.  There's some papers about how [quantizing](https://github.com/TimDettmers/bitsandbytes) works but I haven't wrapped my head around it yet.

#### Falcon

```bash
model=tiiuae/falcon-7b-instruct
volume=$PWD # share a volume with the Docker container to avoid downloading weights every run

sudo docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:1.0.3 --model-id $model --quantize bitsandbytes
```

Falcon isn't gated by an agreement so you don't need a hugging face token to download the model.

Now you can hang out for a while as the model downloads and converts.

Once the model is ready to use, you'll get some logs in your terminal like the following.

```bash
2023-09-23T01:44:05.457262Z  INFO download: text_generation_launcher: Successfully downloaded weights.
2023-09-23T01:44:05.457914Z  INFO shard-manager: text_generation_launcher: Starting shard rank=0
2023-09-23T01:44:15.470495Z  INFO shard-manager: text_generation_launcher: Waiting for shard to be ready... rank=0
2023-09-23T01:44:24.671901Z  INFO text_generation_launcher: Server started at unix:///tmp/text-generation-server-0

2023-09-23T01:44:24.680272Z  INFO shard-manager: text_generation_launcher: Shard ready in 19.221579496s rank=0
2023-09-23T01:44:24.775021Z  INFO text_generation_launcher: Starting Webserver
2023-09-23T01:44:25.295505Z  WARN text_generation_router: router/src/main.rs:349: `--revision` is not set
2023-09-23T01:44:25.295522Z  WARN text_generation_router: router/src/main.rs:350: We strongly advise to set it to a known supported commit.
2023-09-23T01:44:25.833055Z  INFO text_generation_router: router/src/main.rs:371: Serving revision 08751db2aca9bf2f7f80d2e516117a53d7450235 of model meta-llama/Llama-2-7b-chat-hf
2023-09-23T01:44:25.835941Z  INFO text_generation_router: router/src/main.rs:213: Warming up model
2023-09-23T01:44:27.365649Z  INFO text_generation_router: router/src/main.rs:246: Setting max batch total tokens to 10368
2023-09-23T01:44:27.365666Z  INFO text_generation_router: router/src/main.rs:247: Connected
2023-09-23T01:44:27.365673Z  WARN text_generation_router: router/src/main.rs:252: Invalid hostname, defaulting to 0.0.0.0
```

At this point the LLM is ready to use.  I'm pushing against my VRAM limits with this quantized model, if you have a graphics card with less memory you'll probably want to 4 bit quantize with `--quantize bitsandbytes-nf4` or `--quantize bitsandbytes-fp4`.  Below is the output of `nvidia-smi` for my laptop.

```bash
+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA GeForce RTX 3080 ...    On  | 00000000:01:00.0  On |                  N/A |
| N/A   43C    P8              20W / 115W |  14421MiB / 16384MiB |     29%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+
                                                                                         
+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|    0   N/A  N/A      2006      G   /usr/lib/xorg/Xorg                         1043MiB |
|    0   N/A  N/A      2231      G   /usr/bin/gnome-shell                        180MiB |
|    0   N/A  N/A      3990      G   /usr/lib/insync/insync                        3MiB |
|    0   N/A  N/A     11968      G   ...ures=SpareRendererForSitePerProcess      152MiB |
|    0   N/A  N/A     16987      G   ...7209246,18288670158640644548,262144      241MiB |
|    0   N/A  N/A     18540      G   ...sion,SpareRendererForSitePerProcess       52MiB |
|    0   N/A  N/A     19432      G   /usr/bin/nautilus                            11MiB |
|    0   N/A  N/A     35367      C   /opt/conda/bin/python3.9                  12594MiB |
+---------------------------------------------------------------------------------------+
```

### Interacting With The LLM

To interact with the LLM you can send HTTP requests to the container

```bash
curl 127.0.0.1:8080/generate_stream \
    -X POST \   
    -d '{"inputs":"how easy is it to learn machine learning","parameters":{"max_new_tokens":200}}' \
    -H 'Content-Type: application/json'
```

`text-generation-inference` exposes endpoints defined in OpenAPI.  Documentation on parameters can be found [here](https://huggingface.github.io/text-generation-inference/).

You'll get a stream of output as a response with each line representing a token and it's probability.  And at the end of the output is a concatenated string of tokens for a full response.

```bash
data:{"token":{"id":14009,"text":" algorithms","logprob":-0.00030207634,"special":false},"generated_text":null,"details":null}

data:{"token":{"id":322,"text":" and","logprob":-2.3841858e-7,"special":false},"generated_text":null,"details":null}

data:{"token":{"id":4733,"text":" models","logprob":-0.0000026226044,"special":false},"generated_text":"?\n\nMachine learning is a subfield of artificial intelligence (AI) that involves developing algorithms and statistical models that enable computers to learn from data, make decisions, and improve their performance on a specific task over time.\nMachine learning is a rapidly growing field, with a wide range of applications in areas such as:\n\n1. Natural Language Processing (NLP): Developing algorithms and models that enable computers to understand, interpret, and generate human language.\n2. Computer Vision: Developing algorithms and models that enable computers to interpret and understand visual data from images and videos.\n3. Predictive Modeling: Developing algorithms and models that enable computers to make predictions about future events or outcomes based on past data.\n4. Recommendation Systems: Developing algorithms and models that enable computers to recommend products or services based on a user's past behavior or preferences.\n5. Fraud Detection: Developing algorithms and models","details":null}
```

That's it!  You have a LLM running on your machine that you can interact with via an API and all you had to do was install some software and copy and paste a few lines.  What an amazing ecosystem.

If you're looking for a web UI to interact with the LLM, take a look at [oobabooga](https://github.com/oobabooga/text-generation-webui).

## CPU LLMs
If you're on a Mac or don't have a GPU, take a look at the [llama.cpp](https://github.com/ggerganov/llama.cpp).  I haven't ran it myself, but it looks like it's rewritten the underlying tensor math methods in `C/C++`.

Benefits are no dependency on CUDA and perhaps a speed up over Python.  Also instead of being limited by VRAM, I think it relies on system RAM which is much cheaper and easier to upgrade.

## Stable Diffusion

We can also use docker to simplify configuring our environment for stable diffusion.  I haven't found a docker image that contains everything you need,  but you can just copy and paste the the following commands and get something running.  These commands are based off the [stable diffusion instructions](https://huggingface.co/stabilityai/stable-diffusion-2-1) and tailored for using a container.  This will save the generated images to the directory that you started docker from.

> Huggingface libraries download models to the ~/.cache directory.  I haven't investigated enough to figure out how to specify a different directory so you may end up downloading the model multiple times if the container is deleted.

To start a shell with python, pytorch, cuda, etc configured 
```bash
sudo docker run -it --name stable-diffusion --gpus all --shm-size 1g -v $PWD:/images pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel
```

You'll want to save images to the mounted volume so we'll change to `/images`.  Stable diffusion has some library dependencies so we'll install those and start the python interpreter.
```bash
cd /images
pip install diffusers transformers accelerate scipy safetensors
python
```

In Python, we'll import the libraries, create a pipeline, create a prompt to generate the image and save it.

```python
import pytorch
from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler

model_id = "stabilityai/stable-diffusion-2-1"

# Use the DPMSolverMultistepScheduler (DPM-Solver++) scheduler here instead
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
pipe = pipe.to("cuda")

prompt = "a photo of an astronaut riding a horse on mars"
image = pipe(prompt).images[0]
    
image.save("astronaut_rides_horse.png")
```

<div className="Image__XSmall">
  <Image
    src="/images/astronaut_rides_horse.jpg"
    alt="astronaut riding horse on mars"
  />
</div>

And boom, an astronaut riding a horse.  If you're interested in digging deeper into the Stable Diffusion ecosystem, there's a tool for pipelines [ComfyUI](https://github.com/comfyanonymous/ComfyUI) and a [web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)


## Recap
Cool, cool, cool.  You now have LLM and Stable diffusion on your local machine.  You can kind of see how the models + infrastructure work together.  And now that you know how to run models you can start thinking about how to tweak them to your own needs and maybe about tieing multiple models together to create real valuable products.

## What's Next(For The Blog)?
Mobile optimization, a post about creating APIs and a post about learning the basics of ML aka gradient descent to neural networks.  Stay tuned!  And always let me know if this was too simplistic, too complicated or just right.


Learning ML


It started like any other workday.  In the evening, I checked my calendar for morning meetings.  Standard Tuesday morning company standup followed by a meeting with my manager.  The meeting with my manager was a bit odd, we just had a 1:1 a few days prior.  But, it didn't raise any alarm bells, I thought it was a check-in on a project or some questions on how pieces of the platform worked.  

"Companies typically wait until Friday for HR changes right?  Or it happens overnight?" I thought in my head.  I followed the regular evening routine, shower, get the kiddo ready for bed, get into bed myself and putz around on reddit.

The next morning, the company standup followed the same previous patterns.  I went to my next meeting and joined Zoom and the first face to greet me was the head of HR.  

<Blockquote>"Shiiiiiiiit", I thought in my head.  I've followed along the layoffs of other companies and guessed what was about to go down.</Blockquote>

The position was terminated.  The HR lead shared the terms of the layoff - which I think are reasonably generous for a series A startup.  Paid until the end of the month then 4 weeks of severance, healthcare until end of next month.  I dropped off Zoom, and tried to collect my thoughts.  I turned up the music, closed my eyes, leaned back into my chair and took a few deep breaths.

I've been speaking with friends who have been laid off and many describe feeling disrespected.  People spend so much time and effort at a company and overnight they're shown the door.  No farewell with coworkers, just a termination email to their personal account.  I didn't feel contempt for what happend, I think I felt a mix of relief and uncertainity.  This was a forcing function to learn something new, to find new challenges. 

There's probably a future blog post about what I think happened, but I want to focus this post on:

* What happend - Done :heavy_check_mark:
* Why Build A Blog
* What's Next

## Why Build A Blog
I spent the next few days coming up with a strawman gameplan.  Trying to figure out what I cared about, my priorities, and my values.  

I've always shared that if I could retire right now and not worry about financies, I would focus my time and efforts on democratizing education - making high quality education universally accessible (like Khan Academy).  I think access to education and experience absolutely changes life trajectories.

At work, I try my best to share my knowledge and experience.  Some of my ex-coworkers reached out and shared things like the following:

<div className="Image__XSmall">
  <Image
    src="/images/linkedinchat.png"
    alt="LinkedIn Chat Log"
  />
</div>

It reaffirmed my persional values and clarified one of my near term goals.  I want to share my knowledge and experience to help educate others.  I spent 14 years at Google, 2 at a startup - learning by tackling technical and non technical problems.  I'm not an expert in many things, but I'll do my best to share an informed perspective.  In addition, in media we mostly hear about successes.  While successes are great learnings, I think we may even learn more from failures.  I want to be as candid as I can be and share those learnings as well.

Lastly, I felt out of touch with my technical roots.  I haven't put together a full app in a few years and wanted to get back up to speed on modern development.  Last time I did FE development we were still using gulp scripts to compile css / js and the BE was all on Google internal infra.

A blog felt like my preferred medium for sharing information.  However, instead of the easy, efficient choice Medium or Substack, I picked my own stack to get back to speed on web development.  And here we are, this blog [source](https://github.com/pengying/incremental-blog) is hosted on Cloudflare and generated with NextJS, React and a dash of Material UI.  Each post is written in my fave format for documents - Markdown.  And it scores well in Lighthouse (thanks NextJS)!
![Chrome Lighthouse Scores](/images/lighthouse.png)

There's probably also a blog post about figuring out which SSG / web frameworks to use and the hurdles along the way.  I'm guessing there's a few other folks who have posted about it already, but I want to add my learnings about the developer experiences / decision making.

## What's Next
For this blog, I eventually want to treat it more as a conversation than a book.  With a PM lens, I want feedback to understand if the content is useful, and what could make it more useful to readers.  At scale I could probably review anayltics and infer, but conversations are great data points.  I think it could be handed via chat components eg discord or discussing on linkedin but will need to figure that out... later.  For now, shoot me an email at [peng@incremental.fyi](mailto:peng@incremental.fyi).

 In the immediate future I need to spend more time devoted to figuring out the next step in my career and sharing some initial knowledge.  I'll probably also spend some time picking up ML.  

My first series of posts will be sharing my learnings on building APIs and what I think are the most important aspects of a great developer experience.  In terms of API learnings, I'll try to cover the whole gamut - design patterns, schema language, documentation, eng team best practices, client libraries, API gateway, permissions, and more.  In terms of developer experience, I'll focus on it with a product manager lens on it and share how I think about prioritization and rationale.  

If you're looking for someone to help build a differentiated developer experience or a PM / Eng with payments expertise, reach out to me at [peng@incremental.fyi](mailto:peng@incremental.fyi), I am open for work.  My linkedin is below in the socials.

<Blockquote>TLDR; Got laid off, passionate about sharing knowledge, starting a blog to share insights, learnings, failures.</Blockquote>