Abhik Pramanik

Culture

Kyra ran our first holiday book exchange, and it's been a hit with the team (to the point people mentioned it in our 1:1s). I added some photos from our recent meetups.


Ben added some improvements to our Slack guidelines. Sylvie added a way for us to learn more about each other in our weekly standup. We've been using both for over a month, and the team has been enjoying the changes!


How we use efficient and deliberate communication at Ashby to keep Slack notifications and meetings to a minimum, focus 36h out of a 40h week, and have fun along the way 😀.


How Thoughtful Communication Makes Us Unreasonably Productive

aronow.io

Astronomer

Attentive

Aven

Benchling

Boulevard

Brightline

Brigit

Calm

Census

Clever

CloudTrucks

Coder is a remote infrastructure development platform that makes working with code easier than ever. Coder enables everyone from industry rookies to experts to develop code faster than ever before, using templatized starting points and ultra-secure workspaces.

Coder

Cohere

Cointracker

Color

Costanoa Ventures

Decimal

Deel is payroll for modern business. No matter where you're hiring, Deel helps customers run payroll, supporting 150+ countries with hundreds of worldwide experts. Deel helps their customers know that hiring, paying, and managing stayed compliant and easy in their all-in-one platform.

Deel

Deepnote

Deliveroo

Dune

Duolingo

EightSleep is more than a mattress company - it's a suite of products devoted to sleep fitness. Their goal is to make sure that your sleep is as high-performing as you are, helping you meet and exceed the bar for excellence in your waking life. Athletes and scientists alike love their range of highly customizable sleep tech because it helps them live healthier.

EightSleep

Figma

Format One

FullStory

Juni

Linear

Marqeta is a modern card issuing platform dedicated to empowering innovators to launch their products to the world. They have over a decade of experience as a trusted, high-tech solution for builders who need simple, scalable payment solutions.

Marqeta

Modern Treasury

Monte Carlo is a Series D data observability company helping its customers accelerate the adoption of data to eliminate downtime. 

Monte Carlo

Notion

Opendoor

Plato

PostHog

PostHog is an open source analytics platform. Their product is used by product, engineering, and marketing teams to understand user behavior, including product analytics, session recording, user paths, a/b testing, heatmaps, and more. The suite, founded through Y Combinator in 2020, has since been installed by over 10,000 companies.

Pragma Platform

Pulley

Ramp

Readme

Replit

Scratchpad

Sift

Snyk

Sourcegraph

Stytch

Talentful

Treasury Prime

VanMoof is a Dutch e-bike company creating stylish, feature-rich city bikes. They're the fastest growing bike company in the world, with an active community in over 50 cities worldwide.

VanMoof

Veev

Verkada

WeTransfer

Zippin

Engineering

Recruiting

Product

Benjamin Encz

<HeroImage>

![selection lab](/images/selectionlab-header.png)

</HeroImage>

<ColumnLayout>
<Column growAmount="2">
<Date>January 2023</Date>
<MultiTonedHeader>
<Tone color="primary">Ashby partners with The Selection Lab</Tone>
<Tone color="muted">to help recruiters assess perfect-fit candidates.</Tone>
</MultiTonedHeader>

## Integration Information

You’ll be able to automatically measure candidates’ soft skills using built-in workflows and in-the-moment triggers. Generate assessments for candidates in a few clicks, and see the results directly in Ashby as soon as they’re done!
</Column>
<Column>
<CompanyProfile name="The Selection Lab" websiteUrl="https://www.theselectionlab.com/ " websiteLabel="theselectionlab.com" align="raised"
description="The Selection Lab offers a powerful suite of tools to measure competencies, core values, intelligence, and cultural preferences. You’ll use their library of benchmarks to assess candidate responses and generate interview questions to help you get more information. Access it all quickly and easily from Ashby, while never losing track of candidates and their responses."
>

![selection lab logo](/images/selection_lab_logo.svg)

</CompanyProfile>
</Column>
</ColumnLayout>

<FeaturedQuote authorName="Joeri Everaers" authorTitle="COO" companyName="The Selection Lab"
text="Ashby and The Selection Lab are aligned in data-driven recruitment. Our integrated product enables fast-growing organizations to supplement Ashby's recruiting operations data with soft skill data. That data can help you systematically and continuously improve the quality-of-hire."
>

![selection lab logo](/images/joeri-selection-lab.png)

![selection lab logo](/images/selection_lab_logo.svg)

</FeaturedQuote>

<ColumnLayout>
<Column>

### Intuitive

Easy, intuitive set up using an API key

</Column>
<Column>

### Tracking

Seamless tracking of candidate soft skills, responses, and scores on The Selection Lab assessments from within Ashby

</Column>
<Column>

### Notifications

Receive notifications when candidates complete assessments, so you never miss a response and keep your pipelines up to date

</Column>
</ColumnLayout>

<Callout>

<ColumnLayout>
<Column>

## Community Benefit

Offering a 30-day free trial when you connect with Ashby, [click here!](https://www.theselectionlab.com/ashby-integration)

</Column>
</ColumnLayout>
</Callout>

Use a range of scientifically-backed assessment tools to determine if a candidate is right for your open roles and culture, faster than ever.

Ashby partners with The Selection Lab to help recruiters assess perfect-fit candidates

Today we are launching a new feature to enable our customers to seamlessly comply with the pay transparency laws that have recently come into place in Colorado, California, Washington State, and New York City. The pay transparency feature enables customers to publish customizable compensation ranges to job postings and enforce compliance in relevant jurisdictions with a single click.

In designing this feature we aimed to go beyond just compliance. We allow customers to improve their candidate experience by sharing their compensation philosophy and compensation tiers with candidates prominently on their job postings.

Users are now able to list salary ranges, equity, bonuses, commissions, and/or add custom compensation fields, and customize the implementation rules by jurisdiction to ensure compliance.

Customer Tim McCann, Head of Talent at Census, who has been using the feature in beta, shared:

> “I was super excited to use Ashby’s pay transparency feature. It’s incredibly easy to implement, ensures compliance, and has saved my team a lot of time. We have also already seen a qualitative improvement in candidate experience."

![frontend engineer job listing](/images/frontend-eng-listing.png)

*In the Ashby dashboard, users can customize the compensation range to list ranges as a salary, equity, bonuses, commissions, and/or add their own text or number fields. Users can also customize by location, seniority, or custom criteria and add links to compensation or tiering philosophies.*

![a job listing with salary info on a third party site](/images/third-party-listing-with-salary.png)

*Job postings now include compensation ranges which pass through to third party job boards.*

<div style={{position: "relative", paddingBottom: "50.65666041275797%", height: 0}}><iframe src="https://www.loom.com/embed/99ac00f8037541ec8dcf1ab190d0cbb0" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style={{position: "absolute", top: 0, left: 0, width: "100%", height: "100%"}}></iframe></div>

Ashby ships multiple meaningful features each month with the goal of enabling our customers to be truly exceptional at what they do. If you’re interested in booking a demo, [click here](https://www.ashbyhq.com/request-demo?utm_campaign=Content-RecruitingBlog&utm_source=blog&utm_content=Comp-Transparency-Feature).

Ashby is launching a new pay transparency feature to help you stay a step ahead of new salary reporting requirements with ease - read more here.

Ashby Launches Compensation Range Functionality To Enable Seamless Compliance With New Pay Transparency Laws

Chris Lee

With new legislation going into effect across multiple US jurisdictions (Colorado, California, Washington, and others), more and more companies are now obligated to post salary ranges on at least some of their jobs. This trend is expected to continue.

![pay transparency](/images/pay-transparency-chart.png)

_Source: Meghana Reddy / Alamere_ 

At Ashby, we’ve been developing a set of features to help companies be compliant and, if they so chose, improve their recruitment marketing by including compensation on job posts with a varying degree of transparency.  
  
As we’ve been speaking to our customers and other folks in the industry, we’ve been getting a lot of interesting questions around best practices. This post sums up our thoughts — and touches on a few key elements of Ashby’s new pay transparency feature. We hope it’s helpful!  

## How transparent should you be?

The approaches we’re seeing largely fall into two camps. Companies are either focusing primarily on being compliant or they are using this chance to change how they handle compensation throughout the hiring process. We’ll explore both approaches.

### Approach 1: Compliance only

As most regulations go, it’s relatively easy to meet the baseline requirements. We’re seeing some companies choose the path of minimal change and focus entirely on compliance.  
  
**The easiest way to comply is:**  

-   Post salary ranges only on job postings that require it (because you are hiring in a jurisdiction that mandates it)
-   Post ranges only on the job postings in the jurisdictions that require it
-   Post large salary ranges

Ashby now allows our customers to add compensation tiers to their job posts. An approach that focuses only on compliance may end up looking like this:  
  
![sample compensation bands](/images/sample-compensation-bands.png)  
  
While this minimal approach is totally acceptable, there are some downsides to it:  

-   If more companies share complete and more meaningful compensation data, it may make your organization look bad in comparison.
-   Very broad compensation ranges can make conversations with candidates tricky; many will assume they should be ranked at the higher end of the range, even if the evaluation during the interview process doesn’t support that.

As a result we’re seeing more companies using this regulation as an opportunity to bring salary data to all of their job posts in a way that is designed to improve candidate experience and the overall hiring process.  

### Approach 2: Sharing compensation data to improve the hiring process

An alternative approach is to start advertising compensation on your roles more generally, giving you the opportunity to share your compensation philosophy publicly. We are seeing more and more companies take this tactic and go beyond pure compliance.  
  
The main downside to this approach is that it takes a lot of work internally. Especially for larger organizations, being able to publish compensation data _externally_ may take a lot of _internal_ pre-work. If compensation bands were not shared internally up until now, that will likely have to be done concurrently with posting compensation data on jobs.  
  
That said, if you’ve been considering formalizing your compensation bands, now is a great time to prioritize that initiative.  

## Different ways to present your compensation data

Independent of your level of transparency, you will also need to decide _how_ you want to represent your compensation data. We’re seeing companies take a number of different approaches — we’ll explore different options and their tradeoffs below.  

### Providing granular compensation vs. total compensation

Netflix is well known for its unique culture and compensation philosophy. They express compensation on job posts as “total compensation,” which consists of _salary_ + _bonus_ + _equity_ (with a wide range.) They also share their compensation philosophy. Here’s an excerpt from a job posting for a workplace management role at Netflix:  
  
![Netflix’s disclosure policy](/images/netflix-policy-exerpt.png)  
  
The alternative is to break out different components of your compensation, for example, cash vs. equity. The right approach mostly depends on your audience and how familiar they are with the standard compensation structure at your company. For instance, calling out equity compensation specifically may make sense when advertising jobs in markets where candidates are less familiar with receiving equity as part of their compensation package:  
  
![comp with equity](/images/compensation-with-equity.png)  
  
And for earlier stage startups it often makes sense to represent equity as a % of the company instead of a $ value, as shown below:  
  
![comp without equity](/images/compensation-sans-equity.png)  
  
If you’re using Ashby, our pay transparency feature allows you to structure this data whichever way you like. Here’s a quick preview:  
  
![compensation tiering in ashby](/images/ashby-compensation-tiering.png)  

### Tiering

For some roles, you may have multiple compensation tiers (most commonly based on seniority and/or location). You can either represent the entire compensation band as one wide tier, or you can share more granular tiers with candidates. Your approach will depend on how you organize jobs and job postings for your roles within your ATS.  
  
Here are a few different approaches:  

-   Create separate job posts for every tier, by location and/or seniority
-   Create separate job posts for locations, but tier by seniority within each post
-   Create separate job posts for seniority, but tier by location within each post

### Tiering by seniority

With this system, you organize job postings primarily by location, then show seniority tiers within the job post. For instance, you may have a job posting called “Customer Success Manager - US” with the following tiers:  
  
![compensation by seniority](/images/compensation-by-level.png)  
  

### Tiering by location

With this method, you have job posts organized by seniority of candidates. So you may have a job posting called “Senior Customer Success Manager.” Within that job post you then organize by location:  
  
![compensation by location](/images/compensation-by-location.png)  
  
If you are using location-based compensation and have some definition of different location tiers, we recommend including a guide in your job descriptions such that candidates know which compensation band would apply to them.  

## Placing on the job board overview

If you’re aiming to go beyond compliance, you may also want to advertise compensation at the job overview level on your job board. Ashby customers can choose if they want to only share compensation in the job post itself or also want to share it in the overview.  
  
![job board with compensation shown](/images/job-board-with-compensation.png)  
  
This approach will immediately make you stand out as a company that embraces salary transparency which, historically, has led to a higher rate of inbound applications.  

## Enforcing compliance

To ensure compliance with new regulations going forward, you should put a solid system in place. This will be a lot easier if you’re using an ATS, as you can configure job approvals which will allow your team to review any new job postings before they go live.  
  
Within Ashby’s pay transparency feature we even allow you to block jobs from being posted if they _don’t_ show compensation. You’re able to choose if compensation should be required on all job postings or only within specified locations.  
  
![compensation compliance data](/images/compensation-compliance.png)  

## In summary

The new regulations around salary transparency bring some extra work to recruiting teams. But they’re also a great chance to revisit your compensation and recruiting philosophy overall and implement some larger changes in how you and your candidates talk about compensation throughout the interview process.  
  
This change will have many results, one being closer collaboration between talent and people functions. We’re confident that that collaboration will be a huge benefit to everyone.  
  
We hope the guide above is helpful in getting answers to some of the easier tactical questions involved in this change.

The hiring landscape is changing this year, as new pay transparency regulations roll out throughout the US. Ashby is releasing a unique new feature to help you stay compliant - learn more here.

Salary Transparency | Practical Tips for Compliance and Recruitment Marketing

Willem Wijnans

I got into Recruitment because of candidate experience.

2007 – It was my first real job: HR data entry, crunching spreadsheets for the HR manager. At the time I heard a couple of engineering interviews. I’d done some coding and had dabbled in computer science enough to tell that they were asking them the wrong questions. So I offered to help them out with their next engineering interview. And just like that I was in technical recruiting.

I didn't know it back then, but I came to realize that many companies were really struggling with this exact problem. Enough that I was able to build my own brand around helping founders build their engineering teams.

If I could print something on every door of every office, it would be, “Even if we don't want to work with them, they should want to work with us.” That’s the core of candidate experience, and you can create that feeling.

## A Great Experience Is One Where A Rejected Candidate Still Recommends Your Company To Others

The more I've progressed in my career, the more teams I led, the more elements of recruitment I became responsible for, the more I care about the overall experience of that pipeline. My own experience showed me that how you’re treated as an applicant is often a very good impression of how you’ll be treated as a team member, which has led me to relentlessly prioritize experience.

It’s so easy to fall into the trap of prioritizing the people you know you can hire, and letting everyone else drop. But that’s only a short-term win. Someone who isn’t a fit for one role might be a great fit for another. If you’ve made them feel unimportant or overlooked, they won’t want to come back, they will call you out (sometimes on LinkedIn and Glassdoor), and it’s very unlikely they will ever buy your product.

A good candidate experience is one where a candidate feels seen and heard. A great candidate experience is one where a rejected candidate still recommends your company to others.

## Speed, attention, and preparation are the best places to improve an experience

Non-recruiters have a misconception that recruitment doesn’t take time. But it’s one of the most time-consuming tasks because it involves people. Potential recruits aren’t computers that sit in a room waiting for your input. They’re people with lives and feelings. So to achieve a great candidate experience, you have to first abandon that misconception and embrace the fact that it’s going to take time.

### Start with a well-prepared team

Candidates in a newly-opened job too often have poor experiences.

I’d estimate that 80% of jobs aren’t initially specified well, and early candidates end up being unofficial test subjects to help recruiters and hiring managers refine the role. Even if an applicant is excellent, it doesn’t matter if the hiring manager doesn’t know what they want.

Even if it’s an urgent hire, decide what you’re looking for before you start sourcing, so by the time you start filtering people into the pipeline you’re not rushing to build it out in front of them. I recommend you require upfront:

1.  What will the person be expected to do in the role?
2.  A rubric for what qualities/experience they will need and examples of what ‘great’ and ‘poor’ look like.
3.  An interview plan with questions for the interviewers.
4.  If there is an assignment, an outline of the assignment and how it will be assessed.

### Identify and celebrate hiring managers that focus on candidate experience

You need to find the champions that can help you adopt a certain approach - putting candidates at the center - and make sure others look to them to set the culture around hiring. Once you've got that, once talent acquisition and recruitment starts living within the organization, that's when you will start to feel the impact of more formal training.

One way I have seen this done in previous roles was that becoming an interviewer was something you needed to earn. If you were interviewing for the engineering team, it meant you were senior on the team, you had training, you’d done reverse shadowing, and you’d graduated to actually being in front of candidates. It made it something people opted into and truly wanted to do instead of feeling like a chore.

### Ensure hiring managers and interviewers have training

Too many companies think hiring managers will know how to do their job from day one. That’s just not possible. Recruiting takes an entirely different mindset. It’s not fair to expect someone who isn’t familiar with it to take it on naturally. So training for hiring managers and interviewers is crucial. To do this we recommend starting with basic values training, clear expectations of what a candidate will need to be successful, and then track candidate survey results and pass through rates by interviewer to ensure there are no anomalies.

### Ensure hiring managers know who is sourced and who came inbound

Another prepwork fail point is when hiring managers or interviews don't know who has been sourced and who wasn’t. This is always a recipe for bad candidate experience. If the candidate was sourced, they’re already likely to be a good fit - you need to sell them on the company. You want to wait to start interviewing them until they're sufficiently pitched and excited about your company. But interviewers have to know who’s who in order to do that.

### Give candidates all the details before they apply

People want to know how much time they need to invest in the process (especially sourced candidates), so I always put the interview plan up front if possible. It’s a hot topic, but sharing compensation upfront also saves so much time (and is now legally required in a lot of markets too). Waiting until the final stage to discuss compensation is a big waste of time. That kind of clarity helps a lot with the candidate experience; people know what they're signing up for.

### Set candidates up for interview success

What I see going wrong all the time is a failure to set people up for success.

In way too many interviews, the interviewee doesn't know what the interviewers are looking for. It’s a black box, the interviewee can’t prepare. So just tell them. Say:

1.  This is who you're meeting with
2.  This is what they do
3.  This is what they care about on this call

On the candidate's side it’s really detrimental for their experience when they don't know what they need to do to do well. But it’s detrimental to the interviewers, too. It’s so much easier when interviewers are prepared on what to look for, when they know what their goals are. I’ve seen whole interviews where there's no preparation from either side, or every interview at the same stage was different. It’s a horrible experience and it’s completely avoidable.

Most companies that are taking hiring seriously, the first thing that they start implementing is structured interviewing ([these help](https://www.ashbyhq.com/blog/recruiting/hiring-memo).) They build interview feedback systems, or instructions that every person gets. It’s so important to standardize this part of the process.

![an interview plan in ashby](/images/ce1-interview-plan.png)

![more of an interview plan in ashby](/images/ce2-interview-plan.png)

### Offer assessment options that create space for different circumstances

Assessments become a bad experience when they don’t match your work style.

At Ashby, we give engineering candidates the option to do either a take home or an in-person live coding assessment. Different people work better in different ways, and this choice lets engineers play to their strengths and show us their best work.

It makes an impact just having the option and making the hiring process feel like a two-way street.

Too many companies still think that talent is a commodity, or that an eight hour long assessment is normal. And it could be normal, but it depends where you introduce it. For instance, I’m a parent. Before I became a parent, I might have had time to go through an eight hour assessment loop, but right now I can’t do that. It’s an unreasonable friction, and not a predictor of good talent.

At Ashby we do one three hour take home, or you can code live with the team for about an hour and fifteen. People have the option to do what they think is best. Just that one choice, it makes all the difference.

### Reach out often, even for rejections

When we talk about what not to do, ghosting is obvious, right? It’s something we all know: always follow up. But unfortunately, in this day and age, getting a rejection, even if it's a canned message, is a good experience. To go a step further than this isn’t hard though.

Automation is one way. In my time as the Head of Talent at VanMoof, we leveraged Ashby’s Alerts for candidates that had been in the pipeline for more than 5 days. This combination let us move candidates along and out of the pipeline with ease. As recruiters, a place a lot of us struggle is in letting people fall through the cracks – it will improve candidate experience if you put a system in place to stop that from happening in the first place.

![alert automation in ashby](/images/ce3-alert-automation.png)

## Measure for patterns, not numbers

If you’re serious about measuring candidate experience, you can’t just use a typeform then crunch the numbers yourself. You want to use a dedicated tool that can help you visualize the data.

But you only need to ask two or three questions at the absolute max. Consider these:

1.  How likely are you to recommend working at this company to someone else? 
    
2.  I was briefed well on what to expect during each interview (setting candidates up for success is paramount to a good cNPS)
    
3.  Open ended question: “Do you have any general feedback for us” (there will be lots to uncover here)

This is an example of the NPS dashboard I built for the team in Ashby:

![NPS dashboard in ashby](/images/ce4-cnps-dash.gif)

I am particularly proud of having a high cNPS (40) in stage “second round” (left bottom chart). These are all people that fill in our survey when they are rejected for a role:

![survey results in ashby](/images/ce5-graphing.gif)

Scan relentlessly for promoters and detractors who get denied in the final stages of your process.

If you find final-stage detractors who should not have been there in the first place, that’s great discussion material for the team on how to optimize in the future. If they detract because they spotted a genuine issue, like bad interview preparation, that’s valuable information, too.

When you have promoters who were denied in the final stages, you have reason to celebrate and spread this behavior to other teams involved in hiring. Have high-scoring hiring managers meet with hiring managers who don’t score as well for coaching.

As a rule of thumb: The overall cNPS score is a nice thing to look at, but this will also include people you’ve hired, who most likely will be promoters. You really want to look at the cNPS of non-hires, especially those who made it far into the process.

Therefore I always measure cNPS per interview stage - check out the image above to see what that looks like.

## Take small steps to improving your candidate experience

The #1 thing recruiters can do is to automate the bulk work and then focus that freed time on the human elements. Put less time on email copy and more time on being kind and personable. Most modern hiring tech stacks will help you do this, you just need to start early. But this is all in service of helping the actual human side of the recruiters.

You can start small. There's so many points in the candidate journey that you can focus on. Pick one and work on improving it. Every touchpoint a candidate has is a chance to make an impression.

Too many companies don’t start doing this until they’re getting big. So start as soon as you can, and it will help make it easier while helping your company stand out. You don’t have to catch up if you’ve embraced the basics early on.

And the most basic part is being a nice human.

Willem Wijnans has helped dozens of companies recruit and scale - now he's sharing what he's learned about crafting a candidate experience that will make even rejected candidates love your company.

Candidate Experience | Metrics, Processes, And Anecdotes To Go From Good To Great

<HeroImage>

![zinc hero](/images/zinc-integration.png)

</HeroImage>

<ColumnLayout>
<Column growAmount="2">
<Date>November 2022</Date>
<MultiTonedHeader>
<Tone color="primary">Ashby is partnering with Zinc</Tone>
<Tone color="muted">to capture in-depth insights into candidate backgrounds and references worldwide</Tone>
</MultiTonedHeader>

### Leverage our integration with Zinc to make the background check process faster, easier, and less intrusive than ever, helping you 10x your candidate experience.

## Integration Information

With this new integration, you’ll be able to set up in-depth, automated reference and background checks for anyone, anywhere in the world, all without leaving Ashby. Their best-in-class speed and user experience allow Zinc to provide recruiters with unique candidate insights, now seamlessly integrated within Ashby.

This out-of-the-box integration creates unbroken workflows between Zinc and Ashby, ensuring you make awesome, risk-free hires, faster. 

</Column>
<Column>
<CompanyProfile name="Zinc" websiteUrl="https://zincwork.com/" websiteLabel="zincwork.com" align="raised"
  description="Zinc is on a mission to make background checks and references into a seamless process for both you and your candidates."
>

![zinc logo](/images/zinc_logo.svg)

</CompanyProfile>
</Column>
</ColumnLayout>

<ColumnLayout>
<Column>

### Automated Background Checks

You’ll be able to access Zinc from within Ashby, turning background checks into a fast, easy process of just a few clicks - you’ll save time while elevating your candidate experience.

</Column>
<Column>

### Quick Implementation

Visit [Ashby University](https://www.notion.so/Zinc-1105a54a00b74d829b6d00fe4bbfb85b) to learn more about our easy, API key setup

</Column>
</ColumnLayout>

<Spacer size="small" />

<Callout>

<ColumnLayout>
<Column>

## Community Benefit

Ashby customers receive a 10% discount off Zinc. Mention that you're an Ashby customer and your Zinc sales rep will make sure that the discount is applied.

</Column>
</ColumnLayout>
</Callout>

Leverage our integration with Zinc to make the background check process faster, easier, and less intrusive than ever, helping you 10x your candidate experience

Ashby is partnering with Zinc to capture in-depth insights into candidate backgrounds and references worldwide

Ben Asher


At Ashby, we leverage GitHub Actions for lots of small automated tasks. We recently introduced a reminder to deploy changes to production when the number of commits in the deploy passes a specified threshold.

For some background, we deploy by merging `develop` into `master` (via a merge commit). `develop` consists of commits squashed from pull requests. We default to smaller pull requests, so commits may pile up on `develop` if nobody needs to deploy to production right away. Suppose a production issue happens after a deploy and the deploy has lots of commits. In that case, it's harder for our team to roll back (e.g., it has database migrations) and harder to identify the commit(s) that caused the issue. 

To avoid letting deploys accumulate lots of commits, we wanted to figure out a continuous deployment strategy that would keep deploys small. We considered several strategies and, for now, landed on this automated reminder. The reminder has several benefits:

- Deploys are always attended. We wanted to avoid issues where an automated solution might deploy right when everyone signs off for the day in North America or Europe.
- No changes to our deploy process were needed. We're hiring [roles to dedicate more time to improving our deployments](https://jobs.ashbyhq.com/ashby/?departmentId=2c32d70f-d7cb-4a06-bd87-048084e3eb10), but we wanted to reduce deploy size while minimizing immediate effort.

Here's our GitHub Action in its entirety:

```yaml
name: Please Deploy
on:
  push:
    branches:    
      - 'develop'

jobs:
  please-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Check out repository code
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Maybe Ask for Deploy
        run: |
          if [ "$(git rev-list --count origin/develop ^origin/master)" -gt "$MAX_COMMITS_BEFORE_NOTIFY" ]; then
            curl -X POST \
              --data '{ "channel": "C02D678LP29", "text": ":rotating_light: The deploy is getting too big! Can someone (on-call?:pray:) please deploy? https://github.com/ashbyhq/Ashby/compare/master...develop :rotating_light:" }'\
              -H 'Content-Type: application/json; charset=utf-8'\
              -H "Authorization: Bearer $PROD_NOTIFY_SLACK_TOKEN"\
              https://slack.com/api/chat.postMessage 
          fi
        env:
          PROD_NOTIFY_SLACK_TOKEN: ${{ secrets.PROD_NOTIFY_SLACK_TOKEN }}
          MAX_COMMITS_BEFORE_NOTIFY: 4
```

The GitHub Action sends an automated message to our #ping-engineering channel when `develop` is behind `master` by five commits, ensuring that we keep the ship shipping throughout the day!

![Slack Message Screenshot](/images/gridhub-actions-deploy-reminder/slack.png "The automated message in Slack")


An automated reminder to deploy as an effective way to keep deploys small and safe.


Continous Deployment via a GitHub Actions Reminder


ES2022 introduces `Array.prototype.at` and we've come to love using it. `Array.prototype.at` can replace using the standard index operator `[]`:

```typescript
const arr: number[] = [];

arr[0].toString();

// Same as above!
arr.at(0).toString();
```

In the example above, even though index 0 may not have anything there, Typescript is happy to allow us to to call `toString()`. With `.at()`, we get a compiler error:

![Typescripts Compiler Error](/images/array-at/compiler_error.png "Typescript's compiler error.")

`Array.prototype.at` is not officially supported in all versions of Node. Check [node.green](https://node.green/) to see if you can use it!

Array.at provides better type safety than the standard index operator, and it works with Node 16!


Type Safety with ES2022's Array.prototype.at


[`jq`](https://github.com/stedolan/jq) is a tool I use at least two to three times a week (maybe daily when it's my week to investigate sentry issues in production), so I thought I'd write about it and its XML offshoot, `xq` (via [yq](https://github.com/kislyuk/yq)).

A lot of our day-to-day work involves reviewing API request and response data in structured text formats, whether it be debugging, reviewing input or output formats for vendor APIs, etc. Often, I find I have a question about a JSON blob, and that blob is too large to inspect by just giving it a "once over." Enter, `jq`. In it's most basic form, `jq` lets you query JSON documents, but it's also useful for linting and formatting minified JSON.

## Basic Usage

Let's say I have the following JSON blob:

```json
{"firstName":"Ben","lastName":"Asher","email":"ben@example.com"}
```

Copy this to your clipboard and run the following command (after you install `jq` with, for example, `brew install jq`<Footnote>Some other ways to install `jq` are [here](https://github.com/stedolan/jq)</Footnote>)

```bash
pbpaste | jq '.'
```

This prints the following:

```json
{
  "firstName": "Ben",
  "lastName": "Asher",
  "email": "ben@example.com"
}
```

What we did is pipe the output of our clipboard into `jq` and use the `jq` command `.` to print it with better formatting (and colors!). If the JSON were invalid, it would tell you where it's invalid. I've found this immensely useful for quickly fixing issues in our public API documentation since our API documentation vendor requires valid JSON in our sample responses that we present readers.

## Querying JSON

Things get even better when you need to query JSON. I often find myself investigating a Sentry error and debugging an issue that requires inspecting JSON involved in the error. Let's say I have a list of people in JSON format:

```json
[
  {
    "firstName": "Ben",
    "lastName": "Asher",
    "email": "ben@example.com"
  },
  {
    "firstName": "Ronald",
    "lastName": "Martin",
    "email": "ronald@example.com"
  }
]
```

If I want see just emails, I can do `jq '.[].email'`. That `jq` command string tells it to look at each array element (you can also do `.[0]` to select just the first one, for example), and from each one, select the `email` attribute. This prints:

```txt
"ben@example.com"
"ronald@example.com"
```

For a recent issue, I had data like the JSON above, and, if one of the object fields were missing, the backend code threw an error. The amount of data was too large to inspect manually. With `jq`, I could query each attribute, and, if `jq` couldn't find it, it printed `null`. So, to find which attribute was the culprit, I did `jq '.[].email' | grep 'null'` and replaced `email` with each sibling attribute until I got a `null`.

## Querying XML

`jq` is super powerful, but recently I wanted to do something like the example above, but with XML. Our customer job feeds for vendors are in XML and often contain thousands of jobs. I found out a new vendor would not ingest jobs that didn't have a valid two digit country code. Before we launched with the vendor, I needed to figure out how many jobs would be impacted. I figured there must be an equivalent for XML, right? There is, and it's a [tool called `yq`](https://github.com/kislyuk/yq) that wraps `jq` and supports multiple other formats. It ships with a tool called `xq` that you can use for XML.

Back to my task, I needed to figure out how many job postings in the feed would be dropped by the vendor. For simplicity, I'll use the snippet below as our "feed" and walk you through what I did. You can install `yq` with `brew install python-yq`.

Let's copy the feed to our clipboard:

```xml
<?xml version="1.0" encoding="utf-8"?>
<source>
  <publisher>Ashby</publisher>
  <job>
    <title><![CDATA[Product Engineer]]></title>
    <country><![CDATA[US]]></country>
  </job>
  <job>
    <title><![CDATA[Full-Stack Engineer]]></title>
    <city><![CDATA[Remote]]></city>
    <country><![CDATA[CA]]></country>
  </job>
  <job>
    <title><![CDATA[Pilot]]></title>
    <city><![CDATA[Remote]]></city>
    <country><![CDATA[PT]]></country>
  </job>
  <job>
    <title><![CDATA[Software Engineer]]></title>
    <city><![CDATA[Remote]]></city>
    <country><![CDATA[DE]]></country>
  </job>
  <job>
    <title><![CDATA[VP of Sales]]></title>
    <city><![CDATA[San Francisco]]></city>
    <country><![CDATA[United States or Canada]]></country>
  </job>
  <job>
    <title><![CDATA[Data Analyst]]></title>
  </job>
</source>
```

Then save the contents of our clipboard to a file:

```bash
pbpaste > feed.xml
```

From here, I want to query countries. Countries are at the path `.source.job[].country`. I can do the following to quickly check them out:

```bash
cat feed.xml | xq '.source.job[].country' | less
```

Looking at that output, I see some `null`s and some country codes, so I know I'm in right place.

Stepping back, our vendor only accepts two digit country codes. The way our feed code works is that we look up the user-inputted country's country code (for example, via [node-countries](https://www.npmjs.com/package/node-countries)). If we can find the country code, we use it, and, if we can't, we use the original value (people sometimes input invalid countries like "Remote" or "United States or Canada"). Also, some won't have countries, so we see some `null`s.

## Operators

To know what the vendor is going to drop, we can use the length of the country field (only ones of length two will work), which `xq` (and `jq`) can calculate! To get the length of all country codes, I can do this:

```bash
cat feed.xml | xq '.source.job[].country | length' | less
```

That's right! `xq` and `jq` have their own operators, which you can pipe output to within the command. The operator above will output the length of each country, and looking at the output, we can see that we're getting `0`s where we had `null`s before, and `2`s for most things (phew!). To get our final answer, we can run the following command:

```bash
cat feed.xml | xq '.source.job[].country | length' | grep -v '2' | wc -l
```

This takes that output that we were viewing in `less` and pipes it to `grep`. With `-v`, we tell `grep` to only give us output that doesn't match, so that gets us all of the "bad" countries. Piping that to `wc -l` will count the number of lines and give us our answer.

## Conclusion

`jq` and its offshoots are super powerful, and I use them all the time, even if it's just the basic path-based searching of JSON files (or formatting to make smaller ones nicer to read). For everything else, I can usually find a useful operator (via Stack Overflow or [`jq`'s docs](https://stedolan.github.io/jq/manual/)) that'll help me put together fancier queries.


How I use command line tools to inspect JSON and XML data that would be impossible to do by eye.


Querying JSON and XML with jq and xq

Graham Murdoch


In Typescript, when defining a type, it's nice to use a union of [literals](https://www.typescriptlang.org/docs/handbook/literal-types.html):

```typescript
type Sizes = "sm" | "md" | "lg"
```

This allows developers to quickly enter a valid value without having to import and expand an enum. In an editor like VSCode, you get a nice autocomplete prompt with the possible values.

However, sometimes you want a union of literals plus some flexibility for custom values. In this example, we want to allow CSS length units (e.g. `"100px"`). 

A simple solution is to combine the literals with a generic type that is a supertype of the literals:

```typescript
type Sizes = "sm" | "md" | "lg" | string
```

Adding the generic type weakens the type coverage since you can enter something potentially invalid that compiles (like `"lgg"`). You've also broken autocompletion for this type. VSCode, for example, won't show the literals as options in a useful way anymore.

One possible approach is to use a generic type that doesn't match the literal values (e.g. an object):

```typescript
type Sizes = "sm" | "md" | "lg" | { custom: string }
```

This restores autocompletion, some type coverage, and preserves a fallback option. However, it isn't quite what you want for CSS length units (and requires some superfluous decoration). 

## LiteralUnion

Prior to Typescript 4.1, a better solution was to use the `LiteralUnion` utility from the [`type-fest` package](https://github.com/sindresorhus/type-fest):

```typescript
import { LiteralUnion } from "type-fest"
type Sizes = LiteralUnion<"sm" | "md" | "lg", string>
```

While it still allows invalid values, autocompletion of the literal values works again!

## Template Literals

As of Typescript 4.1, we can do better. Using [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html), we can more accurately model (and restrict) the range of values:

```typescript
type Sizes = "sm" | "md" | "lg" | `${number}fr` | `${number}px`;

const size: Sizes = "sm"     // ✓
const size: Sizes = "1fr"    // ✓
const size: Sizes = "100px"  // ✓
```

### Working with Enums

At Ashby, some of our older code uses enums and, for consistency, we continue to use them as the basis for possible values.

Historically, you couldn't really combine the approaches:

```typescript
enum DesignSystemSizes {
  sm = "sm",
  md = "md",
  lg = "lg"
}

type Sizes = DesignSystemSizes.sm | DesignSystemSizes.md | DesignSystemSizes.lg

const size: Sizes = "sm"     // 𝒙 - no literals in autocompletion
```

With template literal types we can!

```typescript
enum DesignSystemSizes {
  sm = "sm",
  md = "md",
  lg = "lg"
}

type Sizes = `${DesignSystemSizes}` | `${number}fr` | `${number}px`

const size: Sizes = "sm"     // ✓ - autocompletes literals and DesignSystemSizes!
const size: Sizes = "1fr"    // ✓
const size: Sizes = "100px"  // ✓
```

## Conclusion

With Typescript 4.1 and later, you can do some pretty interesting things to construct accurate types using literals and template literals. Exciting stuff!

Use template literals to create flexible types that accurately check possible values at compile time and support autocomplete in common editors (like VSCode).


Flexible Types that Support Autocomplete with Template Literals (Oh My!)

Arjun Nayini


When writing tests, especially longer integration tests, sometimes you want to run _nearly_ the same test, but with a few key variables changed. Instead of copying and pasting your integration test into another `it` block and changing the small details, you can use the `.each` table syntax [provided by Jest](https://jestjs.io/docs/en/api#describeeachtablename-fn-timeout):

```typescript
describe.each`
  variable1             | variable2
  ${"mystring"}         | ${true}
  ${"otherstring"}      | ${false}          
`(
  "Testing a variety of cases",
  ({
    variable1,
    variable2,
  }: {
    variable1: string;
    variable2: boolean;
  }) => {
    // Test content...
  }
)
```

The `.each` table syntax<Footnote>You can also define the table as an array of arrays or array of dictionaries.</Footnote> allows you to paste in a string that represents the different test cases you want to run.  The first row defines the names of variables that will be passed to each run of the test.  Each subsequent row represents a test run where the provided values will be bound to the variable names.

In example above, two tests will be run where:

1. `variable1 = "mystring", variable2 = true`
1. `variable1 = "otherstring", variable2 = false`

This technique can make tests a lot more readable. Note that in the above snippet, you'll have access to the variables in the body of the test content.

In using `.each`, I've noticed that it is often best when you don't want to change too much of the test logic based on the variables.  If your test ends up having a lot of `if/else` logic based on the variables, especially throughout the entire body of the test, I think it's better to just copy-paste as the additional complexity to read the test isn't worth it.


How to write similar Jest tests without copying and pasting code.  


Testing Using Jest Table Syntax

Ronald Martin


In standard Typescript, you can make an arrow function [generic](https://www.typescriptlang.org/docs/handbook/2/generics.html) by declaring the type variable before the arguments:

```typescript
const identity = <T>(arg: T): T => arg;
```

However, if you try this in a React `.tsx` file, the compiler tries to parse the type variable as a JSX tag:

![Typescripts Compiler Error](https://static.slab.com/prod/uploads/l73blu9g/posts/images/ysOnK_8JL2tvLGuUSS6I__Rh.png "Typescript's compiler error.")

To help the compiler know that this is actually a generic type variable, put a comma (`,`) after the type variable:

```typescript
// Note the comma 👇
const identity = <T,>(arg: T): T => arg;
```


How to fix Typescript compiler errors from generic arrow functions in .tsx files.  


Featured

How Thoughtful Communication Makes Us Unreasonably Productive

Ashby partners with The Selection Lab to help recruiters assess perfect-fit candidates

Ashby Launches Compensation Range Functionality To Enable Seamless Compliance With New Pay Transparency Laws

Salary Transparency | Practical Tips for Compliance and Recruitment Marketing

Candidate Experience | Metrics, Processes, And Anecdotes To Go From Good To Great

Ashby is partnering with Zinc to capture in-depth insights into candidate backgrounds and references worldwide

Snippets

Continous Deployment via a GitHub Actions Reminder

Type Safety with ES2022's Array.prototype.at

Querying JSON and XML with jq and xq

Flexible Types that Support Autocomplete with Template Literals (Oh My!)

Testing Using Jest Table Syntax

Using Generic Arrow Functions in .tsx Files

Product

Resources

Company

Developers

Featured

How Thoughtful Communication Makes Us Unreasonably Productive

Ashby partners with The Selection Lab to help recruiters assess perfect-fit candidates

Ashby Launches Compensation Range Functionality To Enable Seamless Compliance With New Pay Transparency Laws

Salary Transparency | Practical Tips for Compliance and Recruitment Marketing

Candidate Experience | Metrics, Processes, And Anecdotes To Go From Good To Great

Ashby is partnering with Zinc to capture in-depth insights into candidate backgrounds and references worldwide

Snippets

Continous Deployment via a GitHub Actions Reminder

Type Safety with ES2022's Array.prototype.at

Querying JSON and XML with jq and xq

Flexible Types that Support Autocomplete with Template Literals (Oh My!)

Testing Using Jest Table Syntax

Using Generic Arrow Functions in .tsx Files

Subscribe to Updates

Product

Resources

Company

Developers