The term **bristlecone pine** covers three [species](https://en.wikipedia.org/wiki/Species "Species") of [pine](https://en.wikipedia.org/wiki/Pine "Pine") tree (family [Pinaceae](https://en.wikipedia.org/wiki/Pinaceae "Pinaceae"), genus [_Pinus_](https://en.wikipedia.org/wiki/Pinus "Pinus"), subsection _Balfourianae_). All three species are long-lived and highly resilient to harsh weather and bad soils. One of the three species, _Pinus longaeva_, is among the longest-lived life forms on Earth. The oldest _Pinus longaeva_ is more than 5,000 years old,[\[1\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-oldest-1) making it the oldest known individual of any species.

![bali-monkey](../static/mahkeo-monkey.jpg)

Despite their potential age and low reproductive rate, bristlecone pines, particularly _Pinus longaeva_, are usually a [first-succession](https://en.wikipedia.org/wiki/Primary_succession "Primary succession") species, tending to occupy new open ground.[\[2\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-FEIS-2) They generally compete poorly in less-than-harsh environments, making them hard to cultivate.[\[2\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-FEIS-2) In gardens, they succumb quickly to root rot.[\[3\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-3) They do very well, however, where most other plants cannot even grow, such as in rocky [dolomitic](<https://en.wikipedia.org/wiki/Dolomite_(mineral)> "Dolomite (mineral)") soils in areas with virtually no rainfall.[\[2\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-FEIS-2)

Bristlecone pines grow in scattered [subalpine](https://en.wikipedia.org/wiki/Subalpine "Subalpine") groves at high altitude in arid regions of the [Western United States](https://en.wikipedia.org/wiki/Western_United_States "Western United States"). Bristlecones, along with all related species in class Pinopsida, are [cone-bearing](https://en.wikipedia.org/wiki/Conifer_cone "Conifer cone") [seed plants](https://en.wikipedia.org/wiki/Seed_plant "Seed plant") commonly known as [conifers](https://en.wikipedia.org/wiki/Conifer "Conifer"); the name comes from the prickles on the female cones.[\[4\]](https://en.wikipedia.org/wiki/Bristlecone_pine#cite_note-ARKive-4)

Bali —body, mind & soul


For three years, I have styled my web apps without any `.css` files. Instead, I have written all the CSS in JavaScript.

I know what you are thinking: “why would anybody write CSS in JavaScript?!” Let me explain.

### What Does CSS-in-JS Look Like?

Developers have created [different flavors of CSS-in-JS](https://github.com/michelebertoli/css-in-js). The most popular to date, with over 20,000 stars on GitHub, is a library I co-created, called [styled-components](https://styled-components.com).

Using it with React looks like this:

```js
import styled from "styled-components";

const Title = styled.h1`
  color: palevioletred;
  font-size: 18px;
`;

const App = () => <Title>Hello World!</Title>;
```

This renders a palevioletred `<h1>` with a font size of 18px to the DOM:

<Browser
html={`

  <style>
    .faEkXI {
      font-size: 18px;
      color: palevioletred;
    }
  </style>
  <h1 class="sc-ifAKCX faEkXI">Hello World!</h1>
`}
/>

### Why I like CSS-in-JS

Primarily, **CSS-in-JS boosts my confidence**. I can add, change and delete CSS without any unexpected consequences. My changes to the styling of a component will not affect anything else. If I delete a component, I delete its CSS too. No more [append-only stylesheets](https://css-tricks.com/oh-no-stylesheet-grows-grows-grows-append-stylesheet-problem/)! ✨

<Lesson
  title="Confidence"
  body="Add, change and delete CSS without any unexpected consequences and avoid dead code."
/>

<Lesson
  title="Painless Maintenance"
  body="Never go on a hunt for CSS affecting your components ever again."
/>

Teams I have been a member of are especially benefitting from this confidence boost. I cannot expect all team members, particularly juniors, to have an encyclopedic understanding of CSS. On top of that, deadlines can get in the way of quality.

With CSS-in-JS, we automatically sidestep common CSS frustrations such as class name collisions and specificity wars. This keeps our codebase clean and lets us move quicker. 😍

<Lesson
  title="Enhanced Teamwork"
  body="Avoid common CSS frustrations to keep a neat codebase and moving quickly, regardless of experience levels."
/>

Regarding performance, CSS-in-JS libraries keep track of the components I use on a page and only inject their styles into the DOM. While my `.js` bundles are slightly heavier, my users download the smallest possible CSS payload and avoid extra network requests for `.css` files.

This leads to a marginally slower time to interactive, but a much quicker first meaningful paint! 🏎💨

<Lesson
  title="Fast Performance"
  body="Send only the critical CSS to the user for a rapid first paint."
/>

I can also easily adjust the styles of my components based on different states (`variant="primary"` vs `variant="secondary"`) or a global theme. The component will apply the correct styles automatically when I dynamically change that context. 💅

<Lesson
  title="Dynamic Styling"
  body="Simply style your components with a global theme or based on different states."
/>

CSS-in-JS still offers all the important features of CSS preprocessors. All libraries support auto-prefixing, and JavaScript offers most other features like mixins (functions) and variables natively.

---

I know what you are thinking: “Max, you can also get these benefits with other tools or strict processes or extensive training. What makes CSS-in-JS special?”

CSS-in-JS combines all these benefits into one handy package and enforces them. It guides me to the [pit of success](https://blog.codinghorror.com/falling-into-the-pit-of-success/): doing the right thing is easy, and doing the wrong thing is hard (or even impossible).

### Who Uses CSS-in-JS?

Thousands of companies use CSS-in-JS in production, including [Reddit](https://reddit.com), [Patreon](https://patreon.com), [Target](https://target.com), [Atlassian](https://atlaskit.atlassian.com), [Vogue](https://vogue.de), [GitHub](https://primer.style/components), [Coinbase](https://pro.coinbase.com), and many more. ([including this website](https://github.com/mxstbr/mxstbr.com))

### Is CSS-in-JS For You?

If you are using a JavaScript framework to build a web app with components, CSS-in-JS is probably a good fit. Especially if you are part of a team where everybody understands basic JavaScript.

If you are not sure how to get started, I would recommend trying it out and seeing for yourself how good it feels! ✌️



The cat is out of the bag: I am joining [Gatsby](https://gatsbyjs.com) to work on open source R&D projects, including [Blocks](https://blocks-ui.com), [theme-ui](https://theme-ui.com), [mdx](https://mdxjs.com) and Gatsby themes!

I think Blocks is one of the most exciting open source projects in the React ecosystem right now. Blocks is a visual editor for your React apps: it renders a page of your app and lets you drag-and-drop components to edit the actual underlying code. 🤯

<TwitterTweetEmbed
  tweetId="1199384410199449600"
/>

This has wide reaching implications for the design and development process. Rather than drawing a bunch of rectangles, designers can visually edit code to design new pages. Instead of handing off static images, they can submit pull requests with their new designs.

I believe that a couple of years from now, visual editors will be standard in web development. Everybody will be using them. However, there is a lot of work left to make them great and I cannot wait to be a part of that!



#### Is CSS-in-JS slow?

No. The CSSOM can insert 10,000 unique CSS rules (i.e. classes) in ~60ms ([source](https://twitter.com/threepointone/status/758095801558011904)). Since only the CSS of components that are used on the current page is injected, you will never even come close to 10,000 unique CSS rules.


Pseudotsuga menziesii is an evergreen conifer species in the pine family, Pinaceae. It is native to western North America and is known as Douglas fir,Douglas-fir,Oregon pine,and Columbian pine. There are two varieties: coast Douglas-fir (P. menziesii var. menziesii), and Rocky Mountain Douglas-fir (P. menziesii var. glauca).

Chicharrones kinfolk tumblr narwhal venmo. Iceland cloud bread 8-bit, hashtag single-origin coffee keffiyeh drinking vinegar cray banjo four dollar toast bespoke tbh live-edge celiac. YOLO dreamcatcher hot chicken selvage portland XOXO, single-origin coffee sustainable mustache thundercats fixie pour-over hexagon irony deep v. Farm-to-table ennui mixtape marfa raw denim austin hell of keffiyeh chia prism ethical. Polaroid biodiesel everyday carry VHS hot chicken chartreuse typewriter messenger bag. Cloud bread truffaut street art jean shorts chia.

A trip to Iceland

The Joshua tree is also called _izote de desierto_ (Spanish, "desert dagger").[\[6\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-ITIS-6) It was first formally described in the botanical literature as _Yucca brevifolia_ by [George Engelmann](https://en.m.wikipedia.org/wiki/George_Engelmann "George Engelmann") in 1871 as part of the Geological Exploration of the 100th meridian (or "[Wheeler Survey](https://en.m.wikipedia.org/wiki/Wheeler_Survey "Wheeler Survey")").[\[7\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-IPNI-7)

The name "Joshua tree" is commonly said to have been given by a group of [Mormon](https://en.m.wikipedia.org/wiki/Mormon "Mormon") settlers crossing the Mojave Desert in the mid-19th century: The tree's role in guiding them through the desert combined with its unique shape reminded them of [a biblical story](https://en.m.wikipedia.org/wiki/Conquest_of_Ai "Conquest of Ai") in which [Joshua](https://en.m.wikipedia.org/wiki/Joshua "Joshua") keeps his hands reached out for an extended period of time to guide the Israelites in their conquest of Canaan ([Joshua 8:18–26](https://en.wikisource.org/wiki/Bible_(King_James)/Joshua#8:18 "s:Bible (King James)/Joshua")).[\[8\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-jtnp-8)[\[9\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-9)[\[10\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-10) However, no direct or contemporary attestation of this origin exists, and the name Joshua tree is not recorded until after Mormon contact;[\[8\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-jtnp-8)[\[11\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-11) moreover, the physical appearance of the Joshua tree more closely resembles [a similar story](https://en.m.wikipedia.org/wiki/Rephidim "Rephidim") told of [Moses](https://en.m.wikipedia.org/wiki/Moses "Moses").[\[12\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-12)

Ranchers and miners who were contemporary with the Mormon immigrants used the trunks and branches as fencing and for fuel for ore-processing steam engines. They referred to these fallen or collapsed Joshua trees as _tevis_ stumps.\[_[citation needed](https://en.m.wikipedia.org/wiki/Wikipedia:Citation_needed "Wikipedia:Citation needed")_\]

In addition to the [autonymic](https://en.m.wikipedia.org/wiki/Autonym_(botany) "Autonym (botany)") [subspecies](https://en.m.wikipedia.org/wiki/Subspecies "Subspecies") _Yucca brevifolia_ subsp. _brevifolia_, two other subspecies have been described:[\[13\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-13) _Y. b._ subsp. _jaegeriana_ (the Jaeger Joshua tree or Jaeger's Joshua tree or pygmae yucca) and _Y. b._ subsp. _herbertii_ (Webber's yucca or Herbert Joshua tree), though both are sometimes treated as varieties[\[6\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-ITIS-6)[\[14\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-Grandtner2005-14)[\[15\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-15) or forms.[\[16\]](https://en.m.wikipedia.org/wiki/Yucca_brevifolia#cite_note-Egglid2001-16)

## 

An otherworldly desert

**Juniperus scopulorum**, the Rocky Mountain juniper, is a species of juniper native to western North America, in Canada in British Columbia and southwest Alberta, in the United States from Washington east to North Dakota, south to Arizona and also locally western Texas, and northernmost Mexico from Sonora east to Coahuila. It grows at altitudes of 500–2,700 metres (1,600–8,900 ft) on dry soils, often together with other juniper species. "Scopulorum" means "of the mountains.

![Mauritius Drone Shot](../static/julia-joppien.jpg)

Chicharrones kinfolk tumblr narwhal venmo. Iceland cloud bread 8-bit, hashtag single-origin coffee keffiyeh drinking vinegar cray banjo four dollar toast bespoke tbh live-edge celiac. YOLO dreamcatcher hot chicken selvage portland XOXO, single-origin coffee sustainable mustache thundercats fixie pour-over hexagon irony deep v. Farm-to-table ennui mixtape marfa raw denim austin hell of keffiyeh chia prism ethical. Polaroid biodiesel everyday carry VHS hot chicken chartreuse typewriter messenger bag. Cloud bread truffaut street art jean shorts chia.

The hidden paradise


As the co-creator of styled-components I have spent the past four years thinking about styling React components. Prompted by a lot of conversations and inspirations I have a new dream.

It looks like this:

```js
<div
  styles={{
    flexDirection: ["column", "row"],
    margin: [1, 2],
    padding: 1,
    color: "primary"
  }}
/>
```

Look closely, there are a lot of interesting ideas in here:

- No unnecessary naming
- Enforced consistency via a built-in scale
- Per-value responsiveness
- Simple composition
- Simple refactoring
- Static typing for styles

Let's examine the benefits and tradeoffs.

### Style Objects

Compared to writing CSS in JS as strings (like styled-components uses), objects are are less familiar to developers with no JavaScript experience and are not as easily copy-and-pasted.

On the other hand, the visual noise caused by dynamic interpolations is reduced and composing objects is much simpler.

### Prop Based

Second, you'll notice that I'm passing the style object to a prop of the element. Why a prop and not the familiar `styled.x` API or a `withStyles` HOC?

Naming is one of the hardest things about coding, and with the prop there is no need to create either class names (`.name`) or intermediate components (`Name`). All you have to name is the component you are creating, nothing more.

It also makes refactoring simple, you can copy entire blocks of JSX around without worrying about other parts of your code like HOCs or styled components.

The prop is a small abstraction on top of standard React APIs, making it easy to learn. Further, it can support everything other CSS-in-JS libraries can, including adapting based on props and state, extending and theming.

#### `styles` vs. `css`

I call it `styles` vs. the (currently) more common `css` because that makes it learn once, write anywhere (like React itself). Styling your React Native or ReactVR apps with a `css` prop doesn't make sense, they don't support CSS.

#### Are these inline styles?

They could be, but are not. Inline styles are less performant than compiling to CSS and injecting it into the CSSOM, and they also do not support pseudo-selectors and other nice parts of CSS.

### Built-in Scale

Rather than specifying arbitrary values (`margin: '16px'` or `margin: 16`), only values from 1 to 10 can be specified. There is a global scale, e.g. 4-based: `4px 8px 16px 32px 64px...` (`4 * 2 ^ n`), and the value defines which step on the scale is used. For example, `margin: 2` would result in a `8px` margin.

The same thing is true for colors, rather than allowing any hex/rgb value there is a global set of colors with names, and you pass the color name rather than a raw value.

This means your app is always consistently styled. All the spacing and colors are automatically uniform, leveling up the design. You also have less mental overhead, as you no longer have to decide between a `4px` and `5px` margin, but between a `4px` and `8px` margin.

> TODO: ugly escape hatch for edge cases? maybe `import { __raw }; { margin: __raw('13px') };`

### Responsive Values

Rather than using media queries each property can be responsive (a la facepaint) with mobile-first values.

Again there is a global scale for media queries (e.g. `0px 768px 1200px 2400px`), and specifying `margin: [1, 2]` would mean that anything above 768px has a margin of 8px and everything below a margin of 4px. Need to make a grid of things a column on mobile? `flexDirection: ['column', 'row']`!

This makes it convient and quick to add responsiveness to your app. Because the media queries are mobile-first, it also encourages starting from the mobile layout first, which is a good idea for most apps.

> TODO: Maybe the prop should accept an array to allow swapping out all values? `styles={[mobile, desktop]}`, or maybe that should merge styles? not sure

### Bonus: Static Typing

The style objects can be fully statically typed with TypeScript or Flow!

### Open Questions

- Extending styles: what happens here `<CustomComp styles={{}}>`? Does it pass through `className/style`, `styles` or both?

### Implementation

Identical to emotions `css` prop, this should be implemented as a custom `React.createElement` replacement and handle server-side rendering out of the box.

All the validation should only happen in development. Since there is only simple properties, there is no need for a CSS parser either. This should have a tiny runtime bundle size (< 2kB?).

### Inspiration / Further Reading

- https://mrmrs.cc/writing/2018/06/18/component-styling-api by @mrmrs
- https://jxnblk.com/writing/posts/patterns-for-style-composition-in-react by @jxnblk
- https://style-components.com by @chantastic
  - especially https://medium.learnreact.com/scale-fud-and-style-components-c0ce87ec9772
- https://github.com/threepointone/glam by @threepointone
- https://github.com/jxnblk/rebass
- https://github.com/emotion-js/facepaint

### Primitive properties only

No media queries, pseudo selectors, pseudo elements, shorthands, or anything else.

Clarity over brevity (`margin: 1 1 2 2` vs. `{ marginTop: 1, marginBottom: 2, marginRight: 1, marginLeft: 2 }`).

Need styles on interaction? Do it in JS. CSS pseudo selectors usually do not work well on mobile, and you resolve to JS.



👋 I am Max, the technical co-founder of [Spectrum](https://spectrum.chat). Spectrum is an [open source](https://github.com/withspectrum/spectrum) chat app for large online communities and was recently acquired by GitHub. We are a team of three with a predominantly frontend and design background and have worked on it for close to two years.

Our Node.js servers handled over 12 million background jobs last month, varying from sending an email to processing notifications. Let's dive into how we handle that scale!

### Why Do We Need Background Jobs?

Some user actions trigger complex processes, like sending notification emails and spam checking when users post new messages. We do not want our users to wait long for responses, so we run these tasks asynchronously in the background.

### What Does The Architecture Look Like?

We set up six worker servers that are solely responsible for background processing, and split our ~70 queues between them based on type. For example, one worker ("hermes") sends emails and another ("athena") handles notifications. Each worker is scaled to many instances that share the load.

Our web servers add jobs to the queues and then respond to the users without waiting for the result. Our workers process them asynchronously in the background as they have time.

### Where Are The Job Queues Stored?

To handle that we chose a package called [bull](https://github.com/optimalbits/bull), which uses Redis under the hood. We initially selected it over the alternatives due to its intuitive API, but it has also proven to be the most stable part of our entire infrastructure.

Here is a real-world example of a job from our codebase:

```javascript
// API server
import Queue from "bull";

const messageNotificationsQueue = new Queue("message-notifications");

messageNotificationsQueue.add({
  messageId: message.id
});
```

```javascript
// Worker server
import Queue from "bull";

const messageNotificationsQueue = new Queue("message-notifications");

messageNotificationsQueue.process(job => {
  // ...send message notifications for job.data.messageId...
});
```

### Would We Use Bull Again?



I wish Prisma had existed when we started building Spectrum. It could have helped us move faster and avoid bugs at the same time.



👋 I am Max, the technical co-founder of [Spectrum](https://spectrum.chat). Spectrum is an [open source](https://github.com/withspectrum/spectrum) chat app for large online communities and was recently acquired by GitHub. We are a team of three with a predominantly frontend and design background and have worked on it for close to two years.

### Regret 1: We Did Not Focus On Our Niche

- Wanted to build for our use case, open knowledge communities (e.g. open source)
- Needed to make money, so built business features
- Businesses were not interested, and had we focused on our core niche use case we would have grown much faster
- Easier to raise money if necessary, more satisfying, ultimately more momentum and higher chance at success

<Lesson
  title="Lesson 1"
  body="It's better to have 100 true fans who love the product than 10,000 barely interested users."
/>

### Regret 2: We Did Not Do Enough Marketing

- Spend too much time on building new, shiny features
- Should have spent more time on marketing, typical engineering mistake
- Not just social media, but also in-product growth marketing, marketing pages on the website, etc.

<Lesson 
  title="Lesson 2"
  body="Do way more marketing and sales than you think you need to do."
/>

### Regret 2.3: We Did Not Tell Our Story

- Branding was good and unique
- Brand did not have minimum viable personality https://avc.com/2011/09/minimum-viable-personality/
- It differentiates you from the "big guys" as they cannot have a story as personal as you in most cases
- The Practical Dev (dev.to) is doing a great job at this

<Lesson 
  title="Lesson 2"
  body="Tell your story, it differentiates you from the big players in a crowded market"
/>

### Regret 2.6: We Did Not Launch Often Enough

- Launches are great for marketing, every new release excites customers
- Shipped tons of stuff without ever announcing it
- Missed opportunity to showcase a new feature and get more users at the same time
- Now we are building Changefeed because it was too tedious

<Lesson 
  title="Lesson 3"
  body="Launch before you think you are ready and then again and again and again."
/>

### Regret 3: We Did Not Iterate (Quickly) Enough

- Had an early MVP built with minimal technology (Firebase)
- Saw some tiny traction, thought we needed proper setup for custom functionality

<Lesson 
  title="Lesson 4"
  body="Stick with the minimum viable technology setup until you feel product-market fit. You will know when you have it."
/>

### Regret 4: We Did Not Talk Enough With Users

- Went into a hole and built a shiny feature for months (e.g. WYSIWYG editing) without talking to users about their priorities
- Ended up wasting valuable time and adding a lot of unnessary tech debt

<Lesson 
  title="Lesson 5"
  body="Talk with your users, they should be your guiding star."
/>



### React

Well duh

### GraphQL

When we started building our API, we made the decision to use GraphQL rather than going with a standard RESTful setup. None of us had much backend experience, so the strictness of GraphQL allowed us to avoid many pitfalls, while the simple deprecation and evolution meant we could mess up and would still be fine.

### bull

We knew our API server would need to stay as nimble as possible, so a background job queue was a must. We investigated various technologies (LINK TO PR/ISSUE) and eventually settled on bull due to being based on rock-solid infra (Redis) and its great Node.js API. It has never let us down throughout the many millions of jobs its processed. (a more detailed post about our backend infrastructure will come)

### Prettier

Nothing grinds my gears like code style discussions. Prettier makes it possible to write code in whatever style you prefer, and then have it formatted to the codebase common style on commit. (lint-staged is awesome)

### Static type system

Using a static type system on top of JavaScript has saved us from many bugs. It seems like it should slow down your development, but in fact after a short upfront trudge you speed up and churn out code faster than before.

There are two projects that allow you to add static types to JavaScript, both of which work equally well. We went with Flow due to it having better React support at the time, but I'm sure TypeScript would've worked too.

### Cypress

Integration tests are the bane of many developers existance. They are finnicky, slow and tend to fail to catch bugs. Cypress aims to change that by redefining how browser integration tests are ran. It allows us to test our entire application, front to back, in one swoop and get feedback for every code change whether something fundamental broke.

They still aren't fast, but Cypress tests are much less finnicky and prone to unnecessary failure, making for a much nicer experience using them.



👋 I am Max, the technical co-founder of [Spectrum](https://spectrum.chat). Spectrum is an [open source](https://github.com/withspectrum/spectrum) chat app for large online communities and was recently acquired by GitHub. We are a team of three with a predominantly frontend and design background and have worked on it for close to two years.

With the benefit of hindsight, here are the technology choices I regret and the lessons I have learned.

### Regret 1: Not using react-native-web

A big part of Spectrum's appeal is that the content is public and search-indexed, which is why we built the website before native apps.

Although the search-indexing was a success, our users have been requesting a better mobile experience. We are building native apps now, but starting from scratch is time consuming. If we had used [react-native-web](https://github.com/necolas/react-native-web) to build the website, we could have reused the base components and built the native apps much faster! 🏎💨

On top of that, we should have also optimised the website for mobile first. A great mobile experience on desktop is bearable and only needs tweaking to work well. However, a desktop experience on mobile is annoying, no matter how great, and it has proven hard to make ours work well on devices of all sizes.

<Lesson
  title="Lesson 1"
  body="Building a good product is all about experimentation and momentum. Optimize for iteration speed and flexibility."
/>

### Regret 2: Not using Next.js

We needed server-side rendering for SEO purposes ([client-side rendering does not cut it](https://twitter.com/mxstbr/status/985188986414161921)) but had already built a first version of the app with [create-react-app](https://github.com/facebook/create-react-app). We thought about switching to [Next.js](https://nextjs.org), but I decided that reworking the routing and data fetching would be more effort than building our own server-side rendering server.

Turns out, building your own production-ready SSR setup is tough. It takes a lot of work and it is difficult to provide a good experience, for both developers and users.

Next.js offers an amazing development experience and fast performance out of the box, not to mention the great community and excellent documentation. I would use it in a heartbeat if we started over today (in fact, [this website is built with Next.js](https://github.com/mxstbr/mxstbr.com) 😍).

<Lesson
  title="Lesson 2"
  body="Use existing solutions for technological problems where possible, particularly ones you do not understand deeply."
/>

### Regret 3: Using RethinkDB

I chose [RethinkDB](https://www.rethinkdb.com) as our primary data store mainly because of [changefeeds](https://rethinkdb.com/docs/changefeeds/javascript/). They allow you to listen to live updates on (almost) any query. I thought this would reduce complexity by avoiding a separate PubSub system for real-time functionality.

Unfortunately, we have had a lot of troubles with RethinkDB. Since it is not widely used, there is little documentation and knowledge about operations. We have had many database outages and debugging them has often felt like shooting in the dark.

It also turns out that changefeeds do not scale as well as we had expected. While we managed to work around it, we should not have had to. 😕

Nowadays, I would choose a more established database (Postgres?) and build a PubSub system on top.

<Lesson
  title="Lesson 3"
  body="Carefully choose core technologies that are hard to change later."
  last={false}
/>

<Lesson
  title="Lesson 4"
  body="Prioritize community size and active maintenance, especially in unfamiliar territory."
  first={false}
/>

### Regret 4: Using DraftJS and WYSIWYG editing

Writing is one of the primary activities on Spectrum, so we wanted the experience to be great. I decided to replace our plaintext markdown input with a custom WYSIWYG editor based on [Draft.js](https://draftjs.org), which had recently been released by Facebook.

Unfortunately it did not work out well. The editor is really buggy, even after months of work our users rightfully complain about it constantly. On top of that, the library makes up a majority of our JavaScript bundle size and the lack of cross-browser support means that we have to keep the plaintext input around as a fallback. 👎

Another framework might have worked better, but in reality we should have focused on more pressing features instead. I thought we needed WYSIWYG editing but did not validate it by talking to our users. Otherwise, we would have quickly realised that there was no need for it.

<Lesson
  title="Lesson 5"
  body="Deliberately assess cutting edge technologies, bias towards conservative choices."
  last={false}
/>

<Lesson
  title="Lesson 6"
  body="Be open with your roadmap to learn about your users priorities."
  first={false}
/>

### Takeaways

Changing these decisions would not have made Spectrum a better product by itself. Yet, it would have saved us time and allowed us to spend more time experimenting.

To summarize, here are the six lessons I am taking away for my next projects:

1. Building a good product is all about experimentation. Optimize for iteration speed and flexibility.
1. Use existing solutions for technological problems where possible, particularly ones you do not understand deeply.
1. Carefully choose core technologies that are hard to change later.
1. Prioritize community size and active maintenance, especially in unfamiliar territory.
1. Deliberately assess cutting edge technologies, bias towards conservative choices.
1. Be open with your roadmap to learn about your users priorities.



👋 I am Max, the technical co-founder of [Spectrum](https://spectrum.chat). Spectrum is a chat app for large online communities which GitHub acquired a year ago. We are a team of three with a predominantly frontend and design background and worked on it for three years.

Spectrum was a standard closed source product until 3rd of April, 2018, when we announced that we had [open sourced the entire codebase](https://spectrum.chat/spectrum/general/announcement-spectrum-goes-open-source~556b4915-7269-46a7-96e6-f38446d14146). Why did we decide to open source our entire product?

## The Benefits

The two big reasons for open sourcing our product were feeling good and marketing.


Why we open sourced out product

Starter blog using Tina CMS with Next.js.

Transparent Pricing

Basic

Advanced

Premium

Apply for an account in minutes