Building a todo list from start to finish.

Getting Started with Dart & React


You want to start creating videos for developers but are unsure where to start. It seems daunting – what equipment do I need? How do I edit videos? How do I make them good quality? How do I distribute them?

This guide will teach you everything you need to know to start creating videos for a technical audience. It will explain the fundamentals behind video production and explain the terms you need to know. It will show you how to have excellent video quality in your home studio.

I create videos for my job (in Developer Relations) and have worked as a freelance videographer in the past. This multi-part guide will share tips I've learned over years of creating videos and also include a purchasing guide to save you time. I've done the research, and have different recommendations based on your price range.

- **Part 1: Fundamentals of Video**
- Part 2: Video Equipment & Purchasing Guide
- Part 3: Shooting Videos & Screencasts
- Part 3: Editing & Distributing

## Why Video?

Video is quickly becoming the most common way people consume content. With the global adoption of smartphones higher than ever ([80% of the total population in some countries](https://en.wikipedia.org/wiki/List_of_countries_by_smartphone_penetration)) and improvements to internet speeds, it's easier than ever to stream video. That's why TikTok was one of the [most visited websites in the world](https://www.forbes.com/sites/quickerbettertech/2021/12/26/tiktok-is-now-the-most-visited-website-in-2021and-other-small-business-tech-news-this-week) in 2021.

## Reusing Content

Creators can reuse content in many ways and redistribute it to multiple platforms. Podcasts do this well. They shoot an hour-long video and have:

- The original video version
- Audio-only version
- Individual clips

Then, they can distribute this content in multiple ways:

- Audio streaming services (Spotify, Apple Music)
- Full video to platforms encouraging longer content (YouTube)
- Individual clips to social media platforms

When combined with delegating parts of the creative process (filming, editing, uploading), this can be highly effective for creators. They sit down and have four conversations with guests a month (at an hour each) and have generated 10x content for months to follow.

Most videos should start with a script. A well-written script is the first step of creating an exceptional video. But you've just created another piece of content to distribute – your writing! The same script used for your video can be used for a blog post or a series of tweets.

## Video Outputs & Shot Types

Different video formats require different research, planning, scripting, and output. There are two ways to deliver video: **pre-recorded** or **live**. Live video is gaining popularity but is more challenging than pre-recoded video. For both output types, there are a few common types of shots:

- **Screen recordings:** Showing your editor, terminal, or browser as you explain a topic with audio.
- **Talking heads:** A close-up shot of your subject, where they're speaking to the camera. The term [talking head](https://www.merriam-webster.com/dictionary/talking%20head) comes from traditional media.
- **Mobile-first:** An important separate type because it's typically filmed vertically instead of horizontally.

## Fundamentals of Video

Let's take a look at the terminology and concepts you'll need to understand to successfully create your first video.

### Camera

You can film your videos with your phone, and it's arguably a better option for certain distribution platforms (like TikTok), but you'll want to invest in a [DSLR camera](https://www.adobe.com/creativecloud/photography/discover/dslr-camera.html) for higher quality eventually. You'll hear lots of new terms from the videography industry, so let's break down some of the most important ones.

While some of these terms only apply to DSLR cameras, they're good to know even if you're shooting on an iPhone. In general, the goal is to end up with a shot that's not too dark and not too bright; instead, you want a shot that's _just right_, one with lots of detail.

- **Aperture:** how much light is let into your camera (specifically your sensor). Aperture is measured in terms of _f-stops_ (f/2.8, f/4, f/5.6, etc.). Lower f-stop, more light. Higher f-stop, less light.

<Image
  alt={`Aperture`}
  src={`/static/images/video/aperture.png`}
  width={1422}
  height={556}
/>

- **Exposure:** the brightness of your shot. If a shot is over-exposed, it's too bright and certain parts become “washed out”. If it's under-exposed, it's hard to make out all of the details and the footage can become grainy. Aperture affects your exposure.

<Image
  alt={`Exposure`}
  src={`/static/images/video/exposure.png`}
  width={720}
  height={480}
/>

- **Shutter speed:** the length of time the camera shutter is open while taking a photo. Aperture is measured in sections or fractions of seconds (1/125s, 1/250s, 1/500s, etc.). Shutter speed can affect exposure and the sharpness of your video. For most developer content, you'll likely have a fixed shutter speed for talking heads.

<Image
  alt={`Shutter speed`}
  src={`/static/images/video/shutter-speed.png`}
  width={950}
  height={334}
/>

- **ISO:** how sensitive your camera is to light. A higher ISO means brighter shots. ISO is measured in numbers (100, 200, 800, 1600, etc.). The goal is to keep a low ISO (100) for the best quality. For the type of content developers are producing, you can usually control your environment and lighting to allow for this to happen. Situations where you're filming and it's dark would require a higher ISO or external lighting.
- **Frame rate:** A video is really just a bunch of pictures (frames). The frames per second, or FPS, is how we measure frame rate. Movies & TV typically use 24fps to allow for motion blur. To film slow motion, you want to have a higher fps (60fps or 120fps) to allow for additional frames when you're stretching the video out. Otherwise, the video will look choppy when slow instead of fluid.

<Image
  alt={`Frame rate`}
  src={`/static/images/video/motion-blur.png`}
  width={650}
  height={364}
/>

- **Resolution:** You've probably heard 1080p, which is HD. This is 1920 pixels wide and 1080 pixels tall, expressed as 1920x1080. There's also 4K, which confusingly has 3840x2160 for UHD and 4096x2160 for “cinema” 4K.

<Image
  alt={`Resolution`}
  src={`/static/images/video/resolution.png`}
  width={745}
  height={457}
/>

### Lens

A camera is only as good as its lens. Further, different **focal lengths** affect how the image looks.

The longer the focal length of a lens, the narrow its angle of view. Subjects _appear_ larger with longer focal length lenses than they do with our eyes. Inversely, short focal lengths make subjects seem much smaller than they do to our eyes.

Faces are an excellent demonstration. Long focal lengths make faces appear rounder. Shorter focal lengths make faces appear thinner and amplify features such as noses and eyes.

<Image
  alt={`Focal lengths`}
  src={`/static/images/video/focal-lengths.gif`}
  width={750}
  height={750}
/>

Extremely low focal lengths are called _ultra-wide_ (e.g. 16mm). This is now popularly known as the [GoPro](https://en.wikipedia.org/wiki/GoPro) look, although any lens at that focal length can recreate the same look. For example, 0.5x zoom on an iPhone camera is equivalent to a 13mm focal length.

Extremely high focal lengths are called _telephoto_ and work best for outdoor shooting where you have plenty of space between the camera and subject.

The longer the focal length, the further away you have to place the camera from the subject, which makes filming in small spaces inconvenient. This is why most developers use a wide or ultra-wide lens for indoor shooting.

Different camera brands have [different types of mounts](https://www.studiobinder.com/blog/camera-lens-mounts-types-adapter/) (e.g. A-mount, E-mount, etc.). You need to ensure your lens mount matches your camera. For example, Sony cameras have an E-mount. You'll need to use E-mount lenses, or purchase an [adapter](https://en.wikipedia.org/wiki/Lens_adapter).

### Audio

Audio quality is arguably more important than video quality. Why? **Bad audio quality is worse than bad video quality**. _Especially_ when doing screen recordings.

The goal when recording audio is to prevent [clipping](<https://en.wikipedia.org/wiki/Clipping_(audio)>) – when the audio is too loud and information is lost. You can always raise the volume of your recording, but you can't fix clipped audio. You prevent clipping by monitoring your audio and ensuring the level doesn't “peak”. Aim to record at -12db (decibels).

<Image
  alt={`Peaks`}
  src={`/static/images/video/peaks.png`}
  width={1040}
  height={771}
/>

It's also important to control your environment. Have you ever seen images of artists singing in the studio? Their setup has been [acoustically treated and soundproofed](https://ehomerecordingstudio.com/acoustic-treatment-101/).

<Image
  alt={`Recording studio`}
  src={`/static/images/video/studio.png`}
  width={770}
  height={436}
/>

Soundproofing is the process of making a room resistant to the passage of sound waves. You're blocking sounds from entering the room and preventing internal sounds from escaping. Certain materials, like the paneling on the wall above, absorb and trap sound waves.

You also want to prevent _[plosives](https://en.wikipedia.org/wiki/Plosive)_ (e.g. words with the letter P) from introducing popping sounds. This can make your recording sound unprofessional. This is what [pop filters](https://en.wikipedia.org/wiki/Pop_filter) and windscreens in front of mics prevent.

<Image
  alt={`Pop filter`}
  src={`/static/images/video/pop-filter.png`}
  width={1200}
  height={800}
/>

### Lighting

To nail the professional look, you don't want to rely on natural lighting. You need a predictable, reliable way to light your subject. The most common way is to have a three-point lighting setup with a key, fill, and (hair/rim) light. I recommend watching [this video](https://www.youtube.com/watch?v=j_Sov3xmgwg) to learn more.

<Image
  alt={`Lighting`}
  src={`/static/images/video/lighting.png`}
  width={640}
  height={355}
/>

A lot of lighting comes down to artistic preference. If you want the dramatic look, maybe you only use a single key light so there are more shadows.

You will also want to _diffuse_ the light. This prevents lighting from looking harsh and unnatural, and instead better reflects natural lighting.

If you've ever seen a professional photography studio, you've likely seen lights with diffusers. They often look like umbrellas or large circular coverings on top of lights.

<Image
  alt={`Photo studio`}
  src={`/static/images/video/diffused.png`}
  width={700}
  height={393}
/>

## Conclusion

That's a wrap on the fundamentals of video. You've learned about:

- **Reusing Content**
- **Video Outputs & Shot Types**
- **Cameras**
- **Lens**
- **Audio**
- **Lighting**

Next, we'll learn about the different types of video equipment and I'll share some recommendations for equipment to purchase based on your price range.

- Part 1: Fundamentals of Video
- **Part 2: Video Equipment & Purchasing Guide**
- Part 3: Shooting Videos & Screencasts
- Part 3: Editing & Distributing

If this was helpful, [let me know on Twitter](https://twitter.com/leeerob).


Learn how to start creating videos for developers, including the fundamentals of video production, equipment needed for filming, how to film headshots and screencasts, editing, distributing and more.

Developer's Guide to Video Production: Fundamentals of Video


Typography accounts for [95% of web design](https://ia.net/topics/the-web-is-all-about-typography-period/). Your font choice can be critical for branding, readability, and performance.

[Over time](https://thehistoryoftheweb.com/web-fonts/), recommendations for using web fonts have changed as browsers adopted new standards. Now in 2021, I wanted to learn the best practices for using web fonts on high-performance sites.

## System Fonts

The fastest way to use a web font is none. Browsers include a set of [web-safe fonts](https://developer.mozilla.org/en-US/docs/Learn/CSS/Styling_text/Fundamentals#Web_safe_fonts) (e.g. Arial, Georgia, Times New Roman) you can use by default.

Using web-safe fonts or the [system font stack](https://systemfontstack.com/) will be the fastest option.

```css
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial,
  sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
```

## Why Use Web Fonts?

If system fonts are the fastest option, why do web fonts exist? Branding, improved design, and cross browser and device consistency. [82% of web pages for desktop](https://almanac.httparchive.org/en/2020/fonts) use web fonts.

Let's cover five different areas for high-performance web fonts and conclude with a 2021 recommendation.

- Self Hosting
- Preloading
- Font Display
- Variable Fonts
- Subsetting

## Self Hosting

[Google Fonts](https://fonts.google.com/) is responsible for [70% of all web font usage](https://almanac.httparchive.org/en/2020/fonts#serving-with-a-service). With over 1000 fonts, they provide easy access to quality fonts, multiple formats, and performant defaults (pre-connecting and swapping).

However, **Google Fonts is no longer necessary**. Since 2018, [Google has advised self-hosting](https://developers.google.com/web/updates/2018/08/web-performance-made-easy) for optimal performance through preloading.

There aren't any caching advantages anymore, either. Let's say you're using the font "Roboto", which is [a popular font](https://fonts.google.com/?sort=popularity) on Google Fonts. Chances are you've visited another site using "Roboto" and cached the font.

Since October 2020, Chrome [no longer allows](https://developers.google.com/web/updates/2020/10/http-cache-partitioning) a shared cache across sites. Safari has worked this way since 2013. "Roboto" will be re-downloaded for every site, regardless of it being cached.

When self-hosting, ensure you cache your font with the `Cache-Control` HTTP header. `immutable` tells the browser the file will never change. When a request is made within the `max-age` (1 year), it avoids the roundtrip to ensure it's the latest content.

```bash
Cache-Control: public, immutable, max-age=31536000
```

If you need Google Fonts, [use these optimizations](https://csswizardry.com/2020/05/the-fastest-google-fonts/). With the latest changes in the v2 API, you can tailor fonts to specific users and platforms (including variable fonts).

## Preloading

The browser assigns [loading priorities](https://web.dev/prioritize-resources/) to different types of resources. By default, CSS will be loaded before scripts and images. You can influence the importance of resources by [preloading critical assets](https://web.dev/preload-critical-assets/).

Fonts are discovered late by the browser by default. By preloading, we fetch the font file as soon as possible. Then, the browser caches the font making it available immediately.

Preloading can improve performance metrics like [Time to Interactive](https://web.dev/interactive) and [First Contentful Paint](https://web.dev/first-contentful-paint). For example, Shopify saw a [50% (1.2 second) improvement](https://twitter.com/ShopifyEng/status/844245243948163072) in First Contentful Paint, removing their Flash of Invisible Text (FOIT).

As of 2020, [75% of web fonts use WOFF2](https://almanac.httparchive.org/en/2019/fonts). You likely only need this. For example:

```css
<link
	rel="preload"
	href="/fonts/inter-var-latin.woff2"
	as="font"
	type="font/woff2"
	crossOrigin="anonymous"
/>
```

> Support: All modern browsers except Firefox.

## Font Display

`font-display` allows you to modify the rendering behavior of web fonts with values such as `auto`, `swap`, `block`, `fallback` and `optional`. When loading web fonts, we want to prevent [layout shift](https://web.dev/cls/). This occurs in two ways:

- Flash of Unstyled Text (FOUT) — The fallback font is swapped with a new font (e.g. `swap`).
- Flash of Invisible Text (FOIT) — Invisible text is shown on the page until a new font is rendered (e.g. `block`).

Browsers currently have a default strategy similar to `block`. The only option that eliminates layout shift is `optional`. Combined with the other performance optimizations in this article, `optional` is your best choice.

```css
@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-display: optional;
  src: url(/fonts/inter-var-latin.woff2) format('woff2');
}
```

> Support: All modern browsers

## Variable Fonts

[Variable fonts](https://web.dev/variable-fonts/) allow us to combine multiple styles and weights (e.g. bold, italic) into a single font file.

```css
@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-weight: 100 900; // Range of weights supported
  font-display: optional;
  src: url(/fonts/inter-var-latin.woff2) format('woff2');
}
```

You can try out different variable font options [here](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Fonts/Variable_Fonts_Guide).

> Support: All modern browsers. Even Google Fonts v2 API has support for variable fonts.

## Subsettings

Font files contain multiple languages and glyphs, which increase the file size. Subsetting is the removal of characters you don’t need.

For example, we might use the Inter variable font and subset to latin languages.

```css
@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-weight: 100 900; // Range of weights supported
  font-display: optional;
  src: url(/fonts/inter-var-latin.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
    U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215,
    U+FEFF, U+FFFD;
}
```

## Conclusion

1. Use a variable font
2. Preload your font file
3. Self-host instead of Google Fonts
4. Use `font-display: optional` to prevent layout shift

[Here's an example](https://github.com/leerob/leerob.io) of a site implementing all these recommendations.

## Future

If you need to use `font-display: swap`, future support for [Font Metrics Override](https://www.youtube.com/watch?t=176&v=Z6wjUOSh9Tk&feature=youtu.be) will reduce layout shift when swapping.

```css
@font-face {
  font-family: ...;
  src: ...;
  ascent-override: 80%;
  descent-override: 20%;
  line-gap-override: 0%;
  ...;
}
```


Learn the best practices for high-performance sites using web fonts, updated for 2021.

Web Fonts in 2021


> In this series, you will learn how to [create a dashboard](/dashboard) using Next.js API routes and integrate with third-party APIs.


## Overview

In the first three parts of the series, we learned how to fetch data from a variety of APIs.
Now, we can consume this data visually to build our dashboard.

## SWR

[SWR](https://swr.now.sh/) is a React Hooks library for remote data fetching.
SWR first returns the data from cache (stale), then sends the fetch request (revalidate), and finally comes with the up-to-date data again.

This is important for our dashboard page because it can be left open and the data will remain fresh.
If you re-focus or switch between tabs, SWR will [automatically revalidate data](https://swr.now.sh/#focus-revalidation).

To use SWR, we can import the hook and define which route to fetch.

```js
import useSWR from 'swr';

const { data } = useSWR('/api/unsplash', fetcher);
```

`fetcher` is a small wrapper around `fetch` returning `json`.

```js
export default async function (...args) {
  const res = await fetch(...args);

  return res.json();
}
```

`data` will contain the JSON response from our API route.

```json
// /api/unsplash

{
  "downloads": 7995,
  "views": 1134429
}
```

## Consuming the Data

Now that you have access to the data from the route, you can build a UI to consume the data.
I've chosen to create "cards" for each metric.

```js:components/metrics/Unsplash.js
import React from 'react';
import useSWR from 'swr';

import fetcher from '../../lib/fetcher';

import MetricCard from './card';

function Unsplash() {
  const { data } = useSWR('/api/unsplash', fetcher);

  const downloads = new Number(data?.downloads);
  const views = new Number(data?.views);
  const link = 'https://unsplash.com/@leerob';

  return (
    <>
      <MetricCard header="Unsplash Downloads" link={link} metric={downloads} />
      <MetricCard header="Unsplash Views" link={link} metric={views} />
    </>
  );
}

export default Unsplash;
```

_Note_: The `MetricCard` source code is [here](https://github.com/leerob/leerob.io/blob/6271b16d9f796e5ddbe8ab8289f98b188c688ef3/components/metrics/Card.tsx).

## Example

The two cards below talk to `/api/unsplash` and pull back stats about my Unsplash account.



## Conclusion

This concludes my series on creating a dashboard with Next.js API routes. If you missed the previous posts, they are linked below.

**Create a Dashboard with Next.js API Routes**

- Part 1 - [Unsplash API](/blog/unsplash-api-nextjs)
- Part 2 - [YouTube API](/blog/youtube-api-nextjs)
- Part 3 - [Google Analytics API](/blog/google-analytics-api-nextjs)
- Part 4 - [Fetching Data with SWR](/blog/fetching-data-with-swr)


Learn how to fetch data with SWR, a React Hooks library which improves the developer experience of retrieving data.

Create a Dashboard with Next.js API Routes - Fetching Data with SWR


I've been leading the DevRel team at Vercel for [over a year now](/blog/head-of-devrel), growing from just myself to a team of six. I'm often asked questions like:

- **What is DevRel?**
- **What is DevRel like at Vercel?**
- **Is DevRel a good fit for me?**
- **Will I stop developing if I move to DevRel?**

This post aims to answer these questions, while elaborating on my philosophy behind DevRel and how I've scaled our team.

## What is Developer Relations?

You might hear Developer Relations, Developer Advocates, and Developer Experience used interchangeably. They do have differences depending on the company, so I'll start with how I personally view DevRel.

To me, DevRel is helping **educate developers** and **grow our community**. There are pillars of DevRel that everyone on the team shares ownership for, like developer experience, quality control, and excellence in communication.

<StaticTweet id="1508908852330340370" />

Part of the reason DevRel teams are ran so differently depends on the type of company and industry. So, let's narrow down this post even further: **Developer Relations at DevTools or developer-led companies.**

## What is DevRel like at Vercel?

**DevRel is an integral part of everything we do at Vercel.** We care deeply about developers and their experience using our platform and tooling.

It starts from [Guillermo](https://twitter.com/rauchg) (our CEO) and works it's way down. Great DevRel teams stem from founders who empathize with developer pain. You'll often see `@rauchg` replying to folks on Twitter, asking for feedback on the product or helping customers succeed. He leads by example for the entire DevRel team to follow.

<StaticTweet id="1396320966934859780" />

Since DevRel is such a public facing role, the DevRel team represents the ethos of the company. When we host an event, create a video, meet with a customer, or any other interaction – it should _scream_ Vercel. I believe this comes from being a company that **leads with design**.

Design is user experience _and_ developer experience. It's the DNA of what makes Vercel successful. Everyone at Vercel sweats the details to provide an exceptional experience for customers. We're very blessed with some incredible designers who I've been able to shadow and learn from, helping me (and the rest of the DevRel team) lead with design in _everything_ we do.

One of my goals is to create a positive, uplifting, and vibrant community of developers who are excited about making the web faster. This means you'll find me or others on the team in GitHub, Twitter, Discord, Reddit, Facebook, Hacker News, and everywhere else online learning about how developers use our products and where we can improve.

<StaticTweet id="1517249071702024193" />

In the process of educating developers about the tools and products we provide, we learn what is working well and what's not. Our team then is able to work with product to relay valuable customer insights so we can iterate towards the best customer experience.

## Is DevRel right for me?

I truly believe the demand for DevRel (and content creation in general) is only going to continue increasing at a rapid pace. But I think it's also important to stress you don't _need_ to quit your job to validate if DevRel is right for you.

<StaticTweet id="1383873047619276812" />

You can start creating content today – it's permissionless. No one is stopping you from writing that blog post, creating that video, or teaching others about tech you find interesting. While it's definitely easier to transition from an existing developer/programmer/engineer into DevRel, it's possible to start with DevRel as your first role.

Let's assume you're looking to move into DevRel from engineering, which is the most common path. Here are some questions to ask yourself, along with my own responses that led me to switch to DevRel.

> Are you finding your engineering work fulfilling?

I felt limited, wanting to do more than just code. I knew my experience and skills in writing, design, and video creation could be better utilized. I'd actually had design teams shut down my suggestions to help improve the user experience of the product before.

> If you need to write a one or two-page document outlining an architecture design for a feature you're working on, does that sound fun or dreadful?

Yes. I love writing. Especially clearly articulating tradeoffs for architecture decisions. If we do this, what are the pros? Cons? How does it impact our product in 6 months? 1 year?

> Do you enjoy staying up to date with the latest tools and libraries in your space?

Yes. I love to learn and experiment with new tech. It helps programming feel fresh to me. To be a developer is to be a lifelong learner.

> Do you like to work across teams? Do you enjoy communicating with marketing and product?

Yes. I have an entrepreneurial heart and love seeing and being involved with all parts of how the business runs.

> Are you the type of person who enjoys debates? Can you articulate your points clearly?

It's a skill I've developed over time. Having empathy for other developers and being able to understand their situation and constraints is key.

## Will I stop developing if I move to DevRel?

No, you should continue coding. You can't lose sight of the “developer” part of Developer Relations. To understand and empathize with developers, you need to put yourself in their shoes. Especially if you're advocating for a product developers use.

For example, let's assume you're advocating for a database. You might start to get questions like:

- How does this database compare against [competitor]?
- When would I use [feature] over [feature]?
- What's the best way to build an [industry-specific] app using this database?
- How should I model my data to stay within the free tier?

It's going to be hard to accurately answer these questions if you don't have hands-on experience developing using the product. You should be the first user of beta features and the first to provide feedback to the product team on what's going well (and maybe not so well).

## Growing DevRel Teams

High trust teams are [high growth teams](/blog/hypergrowth). I want to create a team that trusts each other, has autonomy to get their work done, and is given ownership over some part of the experience.

For example, on my team each member has a specific area of focus and ownership. This helps them have a north star for the type of content they're creating, and also allows them to get invested in that segment of the community.

I have a few non-negotiables in terms of how DevRel teams should be ran:

1. It doesn't matter if DevRel reports to marketing, product, engineering, or directly to the CEO. What matter is how the team is given ownership, autonomy, and what metrics [quantify their success](https://www.swyx.io/measuring-devrel).
2. DevRel teams represent the company, but they are also individuals, often with their own following or areas of interest. It's the wrong approach to try and box creatives into company/team structures of the past. The new age of developer creatives are more like professional knowledge athletes, where they represent companies or teams but also have their own independent initiatives.
3. The company does not control your social media accounts. You should never be forced to tweet/share something on behalf of the company from your personal account. Many advocates have worked hard to create an audience that finds their work valuable, and shouldn't be pressured to dilute that. I've heard some horror stories about this and feel pretty strongly about it. You should be creating content or products _so good_ that advocates _want_ to talk about them.
4. You can always, _always_ learn something from your customers. Even when they're complaining on Twitter or upset in GitHub issues. Leading with empathy and a genuine curiosity in how the product could be better will lead to insights others might have ignored. Engaging with upset developers can be tricky, but ultimately [rewarding if done well](/blog/handling-dev-twitter-like-rappers).

If this sounds like a team you'd want to work on, I'm hiring. While I'm open to folks looking for more general DevRel roles, I'm _very_ interested if you match these descriptions:

- You're passionate about build systems, monorepos, CLIs, and making ship happen. This person would work closely with the [Turborepo](https://turborepo.org/) team, as well as every part of building and deploying code on the Vercel platform. You can discuss tradeoffs of how web apps are architected and love to help developers improve performance in every possible way.
- You're passionate about the web, and the growing ecosystem of tools and companies often working together to craft incredible user experiences. You may find yourself trying out the latest database, or the new component library posted on Hacker News. You like to stitch together tools and build examples showcasing interesting open-source libraries. You can craft an impressive Notion doc. This person would work closely with all of our technology partners, like databases, content platforms, ecommerce tools, and more.

That's all for now. Drop me an email at `lee@vercel.com` with three paragraphs on why you'd be a good fit if you're interested in joining.


Learn my personal view of DevRel and how I run our team at Vercel, as well as answers to some frequently asked questions I get.

What is Developer Relations? A Look into DevRel at Vercel




When you send a request using HttpClient, that request passes through a series of message handlers chained together forming a pipeline.

Starts with the reception of the request by the first handler, that does some specific operations and pass to the next handler in line, and so on.

At some point the request is sent, and a response is received and goes back down the pipeline.

DelegatingHandler is just the reverse of Middleware for all the outbound requests.


![DelegateHandler Pipeline](/images/blog/2024-11-12.png)

The problem we want to resolve is to include Authentication on all our requests , we need to request an access token  and include it on every request.


```cs
internal sealed class AuthenticationTokenProvider : IAuthenticationTokenProvider
{
    private readonly HttpClient _httpClient;
    private readonly OAuthOptions _oAuthoptions;
    private Token? _accessToken = null;

    public AuthenticationTokenProvider(HttpClient httpClient, IOptions<OAuthOptions> oAuthOptions)
    {
        _httpClient= httpClient;
        _oAuthoptions = oAuthOptions.Value;
    }

    private async Task<Token> InternalGetTokenAsync()
    {
        var form = new Dictionary<string, string>
        {
            {"grant_type", "password"},
            {"client_id", _oAuthoptions.ClientId},
            {"client_secret", _oAuthoptions.ClientSecret},
            {"username", _oAuthoptions.Username},
            {"password", _oAuthoptions.Password},
        };

        HttpResponseMessage tokenResponse = await _httpClient.PostAsync(_oAuthoptions.Url, new FormUrlEncodedContent(form));
        var jsonContent = await tokenResponse.Content.ReadAsStringAsync();
        Token token = JsonConvert.DeserializeObject<Token>(jsonContent)!;

        return token;
    }

    private async Task<Token> InternalRefreshTokenAsync()
    {
        var form = new Dictionary<string, string>
        {
            {"grant_type", "refresh_token"},
            {"refresh_token", _accessToken!.RefreshToken},
            {"client_id", _oAuthoptions.ClientId},
            {"client_secret", _oAuthoptions.ClientSecret},

        };

        HttpResponseMessage tokenResponse = await _httpClient.PostAsync(_oAuthoptions.Url, new FormUrlEncodedContent(form));
        var jsonContent = await tokenResponse.Content.ReadAsStringAsync();
        Token token = JsonConvert.DeserializeObject<Token>(jsonContent)!;

        return token;
    }

    public async Task<string> GetTokenAsync()
    {
        _accessToken ??= await InternalGetTokenAsync();

        return _accessToken.AccessToken;
    }

    public async Task RefreshTokenAsync()
    {
        if (_accessToken is null)
        {
            await GetTokenAsync();
            return;
        }

        _accessToken = await InternalRefreshTokenAsync();
    }

    private class Token
    {
        [JsonProperty("access_token")]
        public required string AccessToken { get; set; }

        [JsonProperty("expires_in")]
        public required int ExpiresIn { get; set; }

        [JsonProperty("refresh_token")]
        public required string RefreshToken { get; set; }
    }
}
```

We expose 2 methods

GetTokenAsync: to generate the token base on some values stored on our appsettings.json that are passed through dependency injection on the Options pattern.
```IOptions<OAuthOptions> oAuthOptions```

RefreshTokenAsync: to refresh the token , based on the refresh token that we receive on the GetTokenAsync.


Next we want to add this token on every request

```cs
internal sealed class AuthenticationHandler: DelegatingHandler
{
    private readonly IAuthenticationTokenProvider _tokenProvider;
    private readonly AsyncRetryPolicy<HttpResponseMessage> _policy;

    public AuthenticationHandler(IAuthenticationTokenProvider tokenProvider)
    {
        _tokenProvider = tokenProvider;
        _policy = Policy
            .HandleResult<HttpResponseMessage>(r => r.StatusCode is HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden)
            .RetryAsync(3, (_, _) => tokenProvider.RefreshTokenAsync());
    }

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        => await _policy.ExecuteAsync(async () =>
        {
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", await _tokenProvider.GetTokenAsync());
            return await base.SendAsync(request, cancellationToken);
        });
}
```

The AuthenticationHandler class uses Polly to create an AsyncRetryPolicy, this  retry policy wraps the HTTP request and retries it (3 times) when the Status code is Unauthorized or Forbidden. On each retry  calls the refresh token to the AuthenticationTokenProvider gets a new token.
This allows some resilency in case of some failure on the request.


```cs
builder.Services.AddScoped<AuthenticationHandler>();
builder.Services.AddHttpClient(HttpClientHelper.SercoApi, (serviceProvider, client) =>
{
    var sercoOptions = serviceProvider.GetService<IOptions<SercoOptions>>()!;
    client.BaseAddress = new Uri(sercoOptions.Value.ApiUri);
})
.AddHttpMessageHandler<AuthenticationHandler>();
```

To put everything in place we need to register our AuthenticationHandler


and httpclient with our handler


We may want to include other cross-cutting concerns as logging, for that just create a handler for logging

```cs
public class LoggingDelegatingHandler(ILogger<LoggingDelegatingHandler> logger)
    : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        try
        {
            logger.LogInformation("Before HTTP request");

            var result = await base.SendAsync(request, cancellationToken);

            result.EnsureSuccessStatusCode();

            logger.LogInformation("After HTTP request");

            return result;
        }
        catch (Exception e)
        {
            logger.LogError(e, "HTTP request failed");

            throw;
        }
    }
}

```

and register it
```cs
builder.Services.AddScoped<AuthenticationHandler>();
builder.Services.AddHttpClient(HttpClientHelper.SercoApi, (serviceProvider, client) =>
{
    var sercoOptions = serviceProvider.GetService<IOptions<SercoOptions>>()!;
    client.BaseAddress = new Uri(sercoOptions.Value.ApiUri);
})
.AddHttpMessageHandler<AuthenticationHandler>();
```

Hope this helps on your journey.

Using Delegating Handler to add authentication to your requests.

Authentication on your requests


React attempts to be as unopinionated as possible. This is both it's greatest strength _and_ weakness.

Over the years, I've tried many different ways to style my React apps. Each solution has its pros and cons.
This article will share my journey using CSS with React and how it's evolved to its current state. Then, I'll discuss pros/cons of
different approaches for styling.

## Vanilla CSS

Like most, I started web development with vanilla CSS. All you need is a single HTML and CSS file. Pretty simple.

```html:index.html
<h1 class="header">Welcome</h1>
```

```css:index.css
.header {
  font-size: 32px;
}
```

As I built more large applications, I began to understand some of the drawbacks.

- **Reusability.** It's easy to create append-only stylesheets that become very complex.
- **Global Namespace.** Since CSS has a [global namespace](https://css-tricks.com/regarding-css-global-scope/), you can unintentionally target too many elements.
- **Colocation.** It's hard to modularize your CSS, which makes it difficult to delete code safely.

At this point, I was introduced to [CSS pre-processors](https://developer.mozilla.org/en-US/docs/Glossary/CSS_preprocessor).
These tools aim to introduce new funtionality and compile back to vanilla CSS.

## Sass

[Sass](https://sass-lang.com/), one of the most popular preprocessors, allows you to write more reusable, maintainable CSS.
Some of the most popular features are [variables](https://sass-lang.com/documentation/variables), [mixins](https://sass-lang.com/documentation/at-rules/mixin), and [modules](https://sass-lang.com/documentation/modules).

- **Variables.** I want to define global values once and share them throughout my stylesheets.
- **Mixins.** I want to reuse particular snippets of CSS.
- **Modules.** I want to split up my CSS files for a more maintainable codebase.

```scss:_base.scss
$font-stack: Helvetica, sans-serif;
$primary-color: #333;

body {
  font: 100% $font-stack;
  color: $primary-color;
}
```

```scss:_header.scss
@use 'base';

.header {
  font-size: 32px;
}
```

Sass helped me write more modular, reusable CSS – at least, for a while. Over time, I ran into new issues.

- **Naming.** As your CSS grows, it's easy to have class names get out of hand.
- **Browser support.** Certain features aren't [supported across all browsers](https://caniuse.com/) and require [vendor prefixes](https://developer.mozilla.org/en-US/docs/Glossary/Vendor_Prefix) like `-moz-` (Firefox), `-webkit-` (Safari), and `-ms-` (Internet Explorer and Edge).

To solve naming, I started to adopt [BEM](http://getbem.com/introduction/).
Block Element Modifier is a methodology that helps you to create reusable components
and organize CSS in a modular way, which keeps specificity low.

```html
<button class="button">Cancel</button>
<button class="button button--primary">Submit</button>
```

```css
.button {
  color: black;
  background-color: gray;
}

.button--primary {
  color: white;
  background-color: green;
}
```

Naming conventions helped but didn't fix the root cause: **naming is hard**.
For browser support, it's possible to set up your Sass toolchain with a tool like [autoprefixer](https://css-tricks.com/autoprefixer/) to handle vendor prefixes.
However, around this time, I started using component-based frameworks like React. This led me to explore CSS-in-JS.

## CSS-in-JS

My first adventure with CSS-in-JS: building a [component library with styled-components](/blog/ui-component-library-with-styled-components). At first, CSS-in-JS solved all my problems.

- **Specificity** is solved by auto-generated class names.
- **Colocation** is solved by putting CSS directly with the component, making it easy to delete code.
- **Browser support** is solved by having autoprefixer built-in.
- **Variables** are solved by creating a global theme.

However, **naming** was still a huge pain.

As the component library grew, I began to explore [Theme UI](https://theme-ui.com) and [styled-system](https://styled-system.com/).
These were more structured approaches to scaling CSS-in-JS to help enforce a design system.
Plus, they helped solve naming. Trying to scale [styled-components](https://styled-components.com/) alone in a large application made me get _really_ creative with names.
You can only have so many container, wrapper, layout things. For example:

```js
const HomeContainerWrapper = styled.div`
   padding: 8px;
   font-weight: bold;
   color: white;
   background: blue;
`;

<HomeContainerWrapper>
  Hello
</HomeContainerWrapper>

// Forget about naming
<Box
  padding={3}
  fontWeight='bold'
  color='white'
  bg='blue'
>
  Hello
</Box>
```

Now, I know what you're thinking. Inline styles 🤮. I'll admit, I wasn't sold at first. But it grew on me – and that brings us to now.

## Current State

I've recently been working with [CSS Modules](https://github.com/css-modules/css-modules) and [Tailwind CSS](https://tailwindcss.com/).
Both of these approaches to styling React applications have prompted me to step back and evaluate the ecosystem.

Below, I've summarized pros and cons of various approaches to styling your React application. I tried to make this comparison as unopinionated as possible.
The choice that's best for you likely depends on:

- Your experience (stick with what you know).
- Your team.
- The size of your application.
- What you're trying to build.

## Pros and Cons

### Vanilla CSS

### CSS Modules

[CSS Modules](https://github.com/css-modules/css-modules) would be my choice for smaller teams that don't need to share
components across applications.

[Next.js](https://nextjs.org) has support for CSS Modules, which means you don't have to worry about setting up [Webpack](https://webpack.js.org/).
It also sets up [autoprefixer](https://css-tricks.com/autoprefixer/) making CSS Modules an attractive alternative to CSS-in-JS in some cases.



### CSS-in-JS

There's many different CSS-in-JS libraries. The two most popular are [styled-components](https://styled-components.com/) and [Emotion](https://emotion.sh/docs/introduction).

There's also zero-runtime solutions like [Linaria](https://github.com/callstack/linaria), where CSS is extracted to CSS files at build-time.
To see comparisons between different libraries, see [CSS-in-JS benchmarks.](https://github.com/A-gambit/CSS-IN-JS-Benchmarks)



### Theme UI / Styled System

Both [Theme UI](https://theme-ui.com) and [styled-system](https://styled-system.com/) abide by the [System UI theme specification](https://system-ui.com/).
This specification intends to help make UI components, libraries, and tools as interoperable as possible.

The primary use case for these libraries is implenting a component library and design system.
One of my favorite libraries is [Chakra UI](https://next.chakra-ui.com/).



### Tailwind CSS

[Tailwind CSS](https://tailwindcss.com/) has been rapidly growing in popularity. Many people are frustrated with the bloat of CSS frameworks like
[Bootstrap](https://getbootstrap.com/) and want an alternative. Tailwind provides an impressive developer experience with a refined API.

With the combination of [Tailwind UI](https://tailwindui.com/), you can easily build extensible, well-designed applications.


## Conclusion

I hope this article has helped demystify styling your React applications. Did I miss anything or see something you'd change?
Leave a comment below or reach out on [Twitter](https://twitter.com/leeerob).

## Further Reading

- [Switching to Tailwind CSS](/blog/tailwind)
- [What are CSS Modules and why do we need them?](https://css-tricks.com/css-modules-part-1-need/)
- [The Cost of JavaScript in 2019](https://v8.dev/blog/cost-of-javascript-2019)
- [CSS-in-JS library comparisons](https://github.com/andreipfeiffer/css-in-js)
- [Refactoring an alert component from CSS to CSS-in-JS](https://alert-refactor.netlify.app/)
- [Two Steps Forward, One Step Back](https://jxnblk.com/blog/two-steps-forward/)


Learn how CSS has evolved and explore pros and cons of different styling solutions for React.

How Should I Style My React Application?


<Image
  alt={`Content Marketing`}
  src={`/static/images/content-marketing-personal-brand/banner.png`}
  width={1200}
  height={630}
  priority
/>

It's (almost) 2018. You're applying for a new job. You submit your resume to Big Name Co™️. After glancing at it for 10 seconds, what does the hiring manager do?

**They Google you.**

<Image
  alt={`Google`}
  src={`/static/images/content-marketing-personal-brand/google.gif`}
  width={1190}
  height={108}
/>

Have you ever Googled yourself? Based on your online footprint and the uniqueness of your name, you may or may not show up on the first page. What if there was a way to improve your online presence and build your personal brand?

### What Is Content Marketing?

One strategy to build your personal brand is called [content marketing](https://en.wikipedia.org/wiki/Content_marketing).

> Content marketing is a form of marketing focused on creating, publishing, and distributing content for a targeted audience online.

Typically, content marketing is used to attract and transform viewers into customers, but what if you're not selling anything?

You might not be explicitly selling a product, but you are **selling yourself**. You should view yourself as a business, and successful businesses usually have some form of marketing.

### Why Should I Use Content Marketing?

For me personally, I learn best by _doing_. I wanted to drive more content to my portfolio, but I wasn't sure how. I decided to put more focus on creating informative, high-quality content in the form of blog posts. The results have been pretty staggering.

After finishing my last post, [How Stripe Designs Beautiful Websites](/blog/how-stripe-designs-beautiful-websites), I posted a link to the article on [Reddit](https://www.reddit.com/) and [Hacker News](https://news.ycombinator.com/).

<Image
  alt={`Article Initially Posted`}
  src={`/static/images/content-marketing-personal-brand/originally-posted.png`}
  width={1913}
  height={589}
/>

I was immediately receiving 10x the traffic as before. The article ended up hitting #1 on Hacker News and [/r/web_design](https://www.reddit.com/r/web_design/).

<Image
  alt={`#1 Hacker News Article`}
  src={`/static/images/content-marketing-personal-brand/hacker-news.png`}
  width={1680}
  height={184}
/>
<Image
  alt={`#1 Reddit Article`}
  src={`/static/images/content-marketing-personal-brand/reddit.png`}
  width={1680}
  height={184}
/>

This ultimately led to the article being reposted across a bunch of different websites. It continued to grow organically throughout the day, bringing in ~70,000 views in 24 hours.

<Image
  alt={`Article Initially Posted`}
  src={`/static/images/content-marketing-personal-brand/final-views.png`}
  width={955}
  height={472}
/>

This traffic created two notable events:

- My average site traffic doubled
- My portfolio moved from the 3rd page of Google to the 1st

You might be thinking "That's great Lee, but would it work for me?"

### Who Is This For?

- Are you looking for a new job?
- Are you trying to network with your peers?
- Do you aspire to become a [thought leader](http://randsinrepose.com/dont-skip-this/) in your industry?
- Is your name Michael?

_Just kidding_, reader named Michael who is a little freaked out right now.

If you answered yes to any of those questions, this article is for you. Let's use Michael as an example (Sorry Michael).

Michael is a Computer Science graduate from a top university. During his time in college, he had a few internships with some reputable companies and managed to graduate with a 3.5 GPA. At the end of his college career, Michael [created an online portfolio](/blog/beginners-guide-to-the-programming-portfolio) to showcase his work in hopes of landing a job.

Let's evaluate the market.

> Who is Michael's target reader?

Prospective employers and fellow peers in the industry.

> What are they looking for?

- Examples showing he is a proficient programmer
- High-quality content they can learn from
- Impressive written communication skills

Michael decides he wants to start a blog. His goals are to:

- Effectively research and study new topics
- Practice and exercise different skill sets
- Develop and improve his writing abilities
- Attract viewers that could lead to a job opportunity

Ask yourself: Are you knowledgeable about something others would find value in reading? If the answer is yes, **start writing now**.

<Image
  alt={`Spongebob`}
  src={`/static/images/content-marketing-personal-brand/spongebob.gif`}
  width={400}
  height={300}
/>

### How Can I Do It?

Okay, by now I've convinced you this is a good idea. But how do you actually go about _doing_ it?

I'll start by addressing the most difficult part: **You have to be authentic**. You're creating an online identity for yourself. It needs to be _your_ great ideas and thoughts. You can't write some half-assed article you threw together at 2 AM and didn't proofread. You're trying to build trust with the reader.

You need to produce **high-quality content**. You can't write one paragraph and call it good. You have to provide value to your readers. So how do you produce high-quality content?

1.  Research the subject matter and become very familiar with it. You should be educating your readers.
2.  Tell stories with your articles. Make your readers connect with you.
3.  Use humor when appropriate 😄
4.  Include pictures. They're worth 1000 words, remember?
5.  Optimize your article for social media. Read about [meta tags](http://www.wordstream.com/meta-tags) and [open graph](http://ogp.me/).
6.  Don't waste their time - Make your articles concise but still informative.

### Share Your Content

After you've created some content you're proud of, you should:

- Proofread it, and then proofread it again.
- Utilize a tool like [Grammarly](https://www.grammarly.com/) to help prevent spelling issues.
- Share it on social media and any other industry-specific communities.
- Send emails to connect with influencers.
- Be active and respond to readers questions and inquiries.

### Conclusion

Thanks for taking the time to read my article. If you found it valuable, please leave me a comment below! I'd love to hear your thoughts 👍🏼


How to transform your online presence, drive more traffic to your website, and sell yourself.

Using Content Marketing to Build Your Personal Brand


For many teams using Next.js, setting up exception monitoring is a critical requirement before going to production.
This guide will show you how to use [Sentry](https://sentry.io) to catch & report errors on both client and server-side.

## Brief Next.js Overview

Next.js gives you a [hybrid approach](https://vercel.com/blog/nextjs-server-side-rendering-vs-static-generation) for rendering your application.
You can choose on a per-page basis whether you want client-side rendering, server-side rendering, or static-site generation.

Next.js uses [file system based routing](https://nextjs.org/docs/routing/introduction).
All files inside the `/pages` directory will be routed based on their filename (e.g. `/pages/home.js` routes to `your-domain.com/home`).

There are a few Next-specific files you should understand:

- `_app.js` is used to initialize pages and renders on both the client and the server.
- `_error.js` is rendered by Next.js while handling exceptions.
- `next.config.mjs` allows you to override the default configuration.

## Implementing Sentry

> **Update (2021):** This guide has been replaced with the [official Sentry + Next.js example](https://github.com/vercel/next.js/tree/canary/examples/with-sentry).


Learn how to set up Sentry to capture client-side and server-side exceptions for Next.js applications.

Configuring Sentry for Next.js Apps


How did I go from a designer to a developer? In this post, I'll share my overnight success story – ten years in the making. First, we have to go way back to 2007.

## Learning Design

I was 14 and found myself fully immersed in the internet. Like many kids, I was an avid gamer. One of my favorites was Halo. I was on their gaming forums chatting with other Halo players. And for those around my age, you might remember something special at the bottom of every post - forum signature banners.

<Image
  alt={`Old forum banners`}
  src={`/static/images/career/banners.png`}
  width={1280}
  height={720}
  priority
/>

These were _so cool_. I thought "I need to have one". Luckily, I happened to grow up in the internet age. YouTube was getting popular and you could find tutorials on anything your heart desired.

So, 14-year-old me managed to follow the _sound_ advice of others online and download a _completely_ legal version of Photoshop (thanks Pirate Bay) to create my own banners. I learned about vectors, brush packs, masking, typography, you name it. And before I knew it, I was actually _pretty good_ at design.

> **Takeaway:** Follow your curiosity.

## Working as a Designer

I continued to use my Photoshop skills mostly for practical jokes, like photoshopping my friends into epic landscapes or other silly things. When I turned 16, I was looking for a summer job and realized I had actually developed _marketable skills_ in the process of following my curiosity. A local t-shirt company was hiring designers to create vector illustrations for sports teams, events, schools, and more. You know, this kind.

<Image
  alt={`Shirt designs`}
  src={`/static/images/career/shirts.png`}
  width={1280}
  height={720}
/>

I applied, and surprisingly, I got hired. That summer, I churned out designs and learned more about Adobe Illustrator than I could have imagined. As high school graduation approached, it seemed natural I would continue with design in college (university). But a looming fear of a career as a designer led me to explore other options.

I was worried about job stability and the intense cirriculum for designers at my college. In retrospect, I didn't have great guidance (easy to say in hindsight). Ultimately, I made the jump for engineering.

> **Takeaway:** Chase your passions. You might just learn some valuable skills along the way.

## Becoming an Engineer

I started college and learned to code in 2011. I chose Computer Engineering because I built my own gaming computer once, and I was the "IT" person for my friends and family. Not exactly a strong foundation to build a career upon.

My first class was _Introduction to Computer Programming_. My professor asked, "How many have had prior programming experience?". More than half the class raised their hands. My hand stayed down. I became nervous.

I struggled throughout my first year of school, scraping by with average grades and low self-esteem. I wanted to quit. "I'm not smart enough to be a programmer", I thought. In hindsight, I was actually just _learning the wrong things for me_.

## What Didn't Work For Me

In our curriculum, students started out by learning the C programming language. For me, C was not the most enjoyable language to work with. I would be fine never having to manually allocate memory ever again. The only part that sparked joy was visualizing command line output.

```c
#include <stdio.h>

int main( int argc, char *argv[] )  {
   if( argc == 2 ) {
      printf("The argument supplied is %s\\n", argv[1]);
   }
   else if( argc > 2 ) {
      printf("Too many arguments supplied.\\n");
   }
   else {
      printf("One argument expected.\\n");
   }
}
```

For example, if I ran the program above and forwarded `hello` on the command line, I'd see `The argument supplied is hello`. Incredible! While I dreaded almost everything about C, it did start teaching me the fundamentals of programming: variables, loops, functions, and more.

Next, we learned Java. This was a big improvement over C for me. No more [manual memory management](<https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)>)! And even more visual applications: [Java Swing](<https://en.wikipedia.org/wiki/Swing_(Java)>). Now we're talking!

<Image
  alt={`Java Swing program`}
  src={`/static/images/career/swing.png`}
  width={1280}
  height={720}
/>

The next semester we learned web development. This is where the pieces began to fall into place for me. The visual aspect of the web felt like the missing link between design and development. The web felt like a place I could experiment, build, and most importantly **share with anyone**.

> **Takeaway:** To learn what's right for you, cast a wide net. Try many things.

## Humble Beginnings

Even though I was excited about the web, building web apps in 2012 wasn't as beginner-friendly as it is today. I learned HTML, CSS, JavaScript, jQuery, and even that [Bootstrap](<https://en.wikipedia.org/wiki/Bootstrap_(front-end_framework)>) library. Simple websites made sense, but then I was exposed to the world of back-end development... what in the world is a LAMP stack!? [Impostor syndrome](https://en.wikipedia.org/wiki/Impostor_syndrome) reared its ugly head again.

<Image
  alt={`LAMP stack`}
  src={`/static/images/career/lamp.png`}
  width={1280}
  height={401}
/>

Nevertheless, I passed my web development classes with higher marks and ended up landing an internship. It wasn't exactly what I wanted -- I was writing automated tests. But I got my foot in the door. I started to learn what a career as a Software Engineer looked like.

One internship led to two, and then three, and finally a full-time job after graduating [with honors](https://en.wiktionary.org/wiki/cum_laude). Quite a turnaround from wanting to drop out and quit programming just a few years prior. My determination and perseverance paid off.

> **Takeaway:** You're not a failure if your first job isn't at a well-known company. Every company will teach you something new about how to build software.

## Exponential Growth

<StaticTweet id="826528907381739520" />

While I enjoyed web development, the front-end never _fully clicked_ for me until I started using React a few years later in my first full-time job. Up until this point, most "modern web development" at the time seemed so complex. Learning React, and then starting to use Create React App, helped me finally break free from JavaScript build tool hell and focus on building great websites. This is when I started to grow exponentially as a developer.


Specializing on one specific thing (React) led to a snowball effect. Suddenly, I was becoming proficient in other related skills. Understanding the fundamentals led to faster adoption of the next layer of tools, and finally to understanding and creating my own backends and APIs.

> **Takeaway:** Learning React is a safe bet. The principles of React have fundamentally changed how we build for the web.

## The Present

I've now been working with React since 2015. Since then I've largely been a product engineer, working in financial tech and e-commerce. About three years ago, I realized I wanted to make a shift in my career.

I wanted to create. I wanted to write, record, stream, post, tweet, and grow a community. I wanted to help others learn and progress in their careers as developers. After teaching over 100,000 developers from around the world with courses and tutorials, I joined the team at Vercel and now lead [Developer Relations](https://leerob.io/blog/head-of-devrel).

> **Takeaway:** It's never too late to change your trajectory. Your career is a marathon, not a sprint.

## Takeaways & Advice

1. Follow your curiosity.
1. Chase your passions. You might just learn some valuable skills along the way.
1. To learn what's right for you, cast a wide net. Try many things.
1. You're not a failure if your first job isn't at a well-known company. Every company will teach you something new about how to build software. You'll probably only be working there for a few years anyway, on average at least.
1. Learning React is a safe bet. The principles of React have fundamentally changed how we build for the web.
1. It's never too late to change your trajectory. Your career is a marathon, not a sprint.

Also, share your work. Tell people what you're building or learning. It sounds obvious, but learning in public and sharing my findings helped me land multiple jobs in my career.

<StaticTweet id="1334334544598740994" />

- A good boot camp is better than an average degree (for programming).
- You don't need formal education, but if you forego traditional structure and community, you must recreate it yourself.
- Create an [online presence](/blog/beginners-guide-to-the-programming-portfolio#why-do-you-need-a-portfolio). Showcase your work. [Write](/blog/teach-online#writing-online). Share what you've learned. Attract other like-minded people. Create serendipity.

The best time to start was yesterday. The second best time is today.


Learn about my overnight success story, ten years in the making.