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

Ashby and [Rippling](https://www.rippling.com/) are now integrated! Rippling simplifies your employee operations by bringing together HR, payroll, benefits, IT, and more. It’s a one-stop shop for everything you need from onboard to offboard.

![Rippling’s logo](https://dl.airtable.com/.attachmentThumbnails/b454d2a8dadd346e56aba634e2fac058/3217abaf)

Fully integrated, the hires you make in Ashby will transition seamlessly into Rippling, saving you tons of time with each new hire.

To learn more, check out [Rippling’s documentation](https://www.rippling.com/app-shop/app/ashby), and learn more at [Ashby University](https://www.notion.so/Rippling-ec235aafe50e45cc8aa8d5656a67daf7).


Ashby and Rippling now work together - read more about it here.

Ashby Has Partnered with Rippling

Halden Ingwersen

**By Kenza Moller with The Swarm**


Hiring? Finding it more difficult than ever? You’re not alone.  
  
Even as the United States has opened back up, job openings have remained at a record high, with open roles in February outnumbering unemployed Americans by [a record 5 million](https://www.cnbc.com/2022/03/29/there-are-now-a-record-5-million-more-job-openings-than-unemployed-people-in-the-us.html). In 2021, the number of open tech jobs [nearly doubled](https://datapeople.io/tech-hiring-report/state-of-the-tech-hiring-market/) and the average tech listing attracted under [100 applicants](https://datapeople.io/tech-hiring-report/applicant-source-analysis/) for the first time since 2019.  
  
The hiring squeeze has incentivized more startups to expand their reliance on recruiters. Unfortunately, the talent gap has also struck the sourcing field, with the number of open recruiting jobs [outpacing the overall job market](https://www.linkedin.com/business/talent/blog/talent-strategy/data-shows-soaring-demand-for-recruiters) and a quarter of recruiters reporting challenges in [filling sourcing roles](https://www.recruiter.com/recruiting/five-of-the-biggest-recruitment-challenges-concerning-hr-leaders/) on their own teams.  
  
For an early-stage business that isn’t yet dominating job boards, it might seem like hiring has never been more challenging. However, just because it’s becoming harder doesn’t mean recruiting has to be impossible. Here are five ways you can streamline recruiting, even as competition for recruiters grows fierce.  

## Lean into referrals

When it comes to recruiting more efficiently, it’s all about quality over quantity, which is exactly what an [employee referral program](https://community.theswarm.com/c/articles/how-to-build-an-employee-referral-program) (ERP) will do for you. Compared to applicants who apply on a company career site, referred applicants are [nine times more likely](https://datapeople.io/tech-hiring-report/source-of-hire-for-tech-jobs/) to be hired. They also save startups approximately $7,500 per hired referral.  
  
Referrals can be helpful, especially for early-stage startups, who have a harder time competing when it comes to employer brand recognition or salary. Connections can vouch for your company’s culture, opportunities, and mission, and they know ahead of time whether a referral would be a good fit.  
  
The key to running a successful referral program is to mine your contacts extensively, including employees, investors, advisors, and your personal network. Set up [a formalized employee referral program](https://community.theswarm.com/c/plan/creating-your-employee-referral-program) to reward employees for referrals and publicize that you’re looking.  
  
Don’t be afraid to ask your colleagues for introductions. A personal note to your advisors, investors, and personal connections can bring a ton of referrals your way, and job postings shared on one’s own LinkedIn or Twitter can garner interest from your networks.  

## Don’t overlook a career-changer

If you limit yourself to hiring a tech recruiter, you’re pretty much guaranteed competition. But if you’re willing to get creative, you may still have an excellent recruiter on your hands, even if they have a different background.  
  
Plenty of talented employees in other roles, from customer service to sales, may make great recruiters, especially if they’re already familiar with your industry. The overlap between tech recruiting and other fields has already been recognized by companies like [Recruit Rise](https://www.recruitrise.io/home), which help career switchers train for a role in tech recruiting in just nine weeks.  
  
Rather than compete for an experienced recruiter, consider someone with experience in your field and a desire to try out tech recruiting. If you hire for soft skills and cover their training for the hard skills, you might just end up with a talented recruiter who has deep experience in your field.  
  
Of course, this goes for other roles as well. If you can train and promote from within, you can save yourself the hassle of competing for external talent. [Promoted employees](https://www.umassglobal.edu/news-and-events/blog/promoting-from-within) not only save employers an average of 18% compared to external hires, but their performance reviews tend to be better for at least two years after promotion.  

## Outsource certain tasks — to technology

Whether you work with an in-house recruiter or you’re sourcing all applicants yourself, certain software tools can help you do more with less. Outsourcing certain tasks — from sourcing and screening to scheduling and follow-ups — can help you increase your bandwidth without having to hire on additional recruiters.  
  
Today, technology exists to streamline all stages of the recruiting and hiring process. A few areas you might consider include:  

-   Using an Applicant Tracking System (ATS) (like [Ashby](https://app.ashbyhq.com/product?partner=underdog#sourcing)) to help you source candidates, automate communication and high-volume interviews, and track your pipeline.
-   Leveraging platforms like [Knockri](https://www.knockri.com/), which use AI to remove systemic bias from the interviewing and hiring process.
-   Outsourcing technical interviews to companies like [Karat](https://karat.com/), where trained engineers can screen candidates for the specific technical skills you need.

## Embrace transparency

Hopefully, honesty and transparency are already part of your company M.O. — but if you want to beat the competition in the war for talent, you may want to take it a step further.  
  
Job seekers today, including recruiters, are increasingly looking for jobs that match their goals in terms of values, work/life balance, and pay. And when competition is fierce, any company that can share data around those pillars will stand out. (According to Indeed Canada, job postings that share salary data receive up to [90% more applicants](https://www.cbc.ca/news/business/pay-transparency-job-postings-youth-1.6435727).)  
  
Transparency isn’t only helpful because it increases the number of candidates attracted to your role, either. It also helps disqualify those who aren’t a good fit for your company early on; that helps you save time and ensure that those you _do_ interview are actually well-aligned with your company.  
  
How can you be more transparent when recruiting?  

-   Include salary ranges for each position
-   Don’t just share that you have a “generous” vacation or healthcare policy — share the policies themselves
-   Don’t preach “work-life balance” if your teams frequently work late; be honest about the challenges and opportunities that come with certain roles or your company’s growth stage
-   Be open about where you are in your diversity, equity, and inclusion efforts, instead of simply saying that you’re committed to them

## Use storytelling to stand out from the crowd

As an early-stage business, it’s unlikely that prospective recruiters or employees will know your company name or your employer reputation before applying. Rather than considering this a challenge, use it as an opportunity: you get to share your story exactly as _you_ would like it shared.  
  
Leverage [the principles of storytelling](https://community.theswarm.com/c/closing-candidates/storytelling-in-recruiting) at all stages of outreach, interviewing, and hiring. Start by setting up a Careers page that clearly shares your mission, what it’s like to work for you, and the impact individual employees can have at work. Continue by sharing employee stories on LinkedIn and teaching employees (and leadership!) how to become thought leaders on Twitter and LinkedIn.  
  
Don’t forget to continue telling the story when you reach out to candidates and interview them. Focus on them as the main character: what mission are they helping to solve? How do they fit into the puzzle? Who are the other characters along for the ride with them? A compelling story can help you compete against those who may have an edge in available salary or brand awareness.  

## Work smarter, not harder

As an early-stage startup, the labor squeeze can seem overwhelming. Luckily, there are plenty of ways to streamline your recruiting efforts and stand out. And the best part is that all of these efforts pay dividends as you scale — so that even if hiring becomes effortless for your teams, these systems and practices continue to pay off.  
  
*This post was written by Kenza Moller in collaboration with [Ashby](https://app.ashbyhq.com/access) and [The Swarm](https://www.theswarm.com/). The Swarm makes it easy for companies to source referrals from their collective networks.*

Ashby has partnered with The Swarm to do a deep-dive on the current state of hiring recruiters, and how you can beat the competition and nab the recruiter you need.

The Last Recruiter: How Startups Can Handle the Fierce Competition for Recruiters Today

Ashby is now integrated with [HiBob](https://www.hibob.com/?utm_source=partner+page&utm_medium=blog&utm_campaign=ashby)! HiBob’s intuitive and data-driven HR platform, Bob, was built for the way people work today: globally, remotely, and collaboratively. From out-of-the-box onboarding, workflows, performance management, and compensation management to engagement features and people analytics— Bob is core HR and more.

![Bob’s logo](/images/boblogo.png)

Together, the transition from Ashby’s data-driven hiring to Bob’s inclusive people management tools is faster and easier than ever before.

To learn more about this great integration, checkout [Bob’s documentation](https://www.hibob.com/?utm_source=partner+page&utm_medium=blog&utm_campaign=ashby) and [Ashby University](https://www.notion.so/ashbyhq/Ashby-University-efd04871f5554358ada837de165070ca).


Ashby and Hibob have a new integration - learn more here.

Ashby Has Partnered with HiBob

Candidate experience is critical for recruiters, but how can you know that yours is truly top notch? Is it even possible to take the assumptions and guesswork out of candidate experience?  
  
The most effective way to know for sure is to get data from your candidates in the form of a survey. But, even then, not all surveys are created equal. Your survey needs to ask the right questions in the right way to truly get to the core of your candidate experience.  
  
We spoke to several professionals in the Talent and Recruiting Operations space to see how they approach surveys, and what you can do to replicate their success. This article will walk you through what to ask, how to ask it, and what you should keep in mind as your candidates fill it out.  

## Why candidate experience is key

First impressions have a huge impact on how humans think and feel about new people and groups. And, for a potential new employee, candidate experience is their first impression of your company. You could be the best place to work in the world, but if the process of applying for a job is horrible, you’ll still struggle to attract quality talent.  

> “A company can unknowingly go from an amazing experience to a miserable one without the insights that allow your team to catch things like the need for interviewer training refreshers.” - Destiny Lalane
  
In a 2021 CareerPlug survey, they found that [58% of respondents declined a job offer because of a poor candidate experience](https://www.careerplug.com/blog/candidate-experience-statistics/). That’s a staggering number, but if you’ve ever had a poor hiring experience, you’re probably not surprised. It can feel frustrating, disorienting, or demeaning to go through a hiring process where the hiring team feels checked out, distant, or dismissive.  
  
The problem is that no hiring team is acting that way on purpose. (After all, who would want to lose out on good candidates?) Most negative candidate experiences come from pure ignorance of how bad the process really is. That’s why no guide on how to improve your experience will help until you know what experience you’re already creating.  
  
Destiny Lalane, Talent at Ashby, weighed in here. “A company can unknowingly go from an amazing experience to a miserable one without the insights that allow your team to catch things like the need for interviewer training refreshers.” You can avoid that ignorance by thoughtfully scaling your recruiting team, training your recruiters, and, as we’ll discuss here, studying data from high-quality surveys.  
  
Now that you know how vital creating a good candidate experience survey is, let’s see how to do it.  

## Timing

When should you send your candidate experience survey? That depends on what you want.  
  
The “end point” of your funnel is going to look different for different applicants, depending on how far along they get. Destiny says to ask yourself, “What kind of information are you trying to collect? At what volume are you interviewing? This will help you decide.”

Jeremy Lyons, Talent Partner at SGNL.ai and former Manager of Recruiting Operations at Wish, told us that, "The further along an applicant gets in your process, the more likely they are to fill out your survey and provide high-quality answers."  
  
Make sure to note how far along a candidate was when they filled out the survey! That will help you to identify if your experience is great up to a point, or if you have an issue further along your pipeline.  
  
For rejected candidates, there is one more element to consider: don’t send your survey too soon. Candidates who were rejected may not be quite so glowing as candidates who were hired. And if you send a survey and a rejection in the same email, you’re not setting yourself (or them) up for fair and objective feedback. Send the rejection, then wait two or three days for any especially negative feelings to die down before requesting feedback. This will help ease negative bias in the survey, even if it might not eliminate it fully.  
  
Jeremy also pointed out that there’s more to timing than how long it’s been since you gave your applicant an answer. “Something that gets overlooked here is the time of day that you are sending your survey,” he told Ashby. “You want to send it between 11:00 AM - 12:30 PM. People are often distracted during that window and looking for something else to do. If that is the case, they'll blitz through a survey you send.”  

## Length

Once you’ve decided when to send your survey, you should consider the length. Brevity is your goal here; aim to get the best information in the shortest time possible.  
  
Lalane recommends no more than five or six questions. “You're asking for a favor, for feedback, which is very valuable,” she told us. “You want it to be as easy as possible to get the information you most care about.”  
  
That might mean you need to make a few trade offs. If you want a lot of detail, for instance, consider using long-form text boxes and asking open-ended questions, but just two or three total questions. On the other hand, you may be able to ask an extra question if all the questions are in a simple scale or multiple-choice style.  
  
Beware survey fatigue! Odds are good that a candidate is filling out multiple job applications and being asked to complete multiple candidate experience surveys. Make it easy for them to choose to complete yours.  

## Questions

We’ll begin with a few guidelines for the types of questions you might need under different circumstances. Nobody outside of your organization can tell you _exactly_ what questions to ask. Your company and interview process is unique, as is the information you want to learn with this survey, so your questions need to be custom-tailored to fit. That said, we’ve included a few examples for ways to get this information, along with the style of survey question it is.  

**Timelines of responses / Speed of responses-** Are your communications prompt? Did the process drag out too long?
- _1-10 Scale_ I didn’t have to wait long to hear back from my recruiter
- _Extended Response_ Did you feel that communication was prompt?

**Professional attitudes-** Was your team professional in all of their communications? Do your interviewers need more coaching on effective interviewing? Did your interviewers appear prepared? Did they give you time to complete your answers with minimal interruptions?
-  _1-10 Scale_ Everyone I spoke to was professional and polite.
-  _Multiple Choice_ How would you describe the team members who interviewed you? (Professional, Rude, Excited, Knowledgeable, Disengaged, Withdrawn)

**Sourcing-** Where did you get the bulk of your candidates? This is especially useful to see if word of mouth, paid marketing, or in-house referrals are making a big impact on your sourcing.
- _Multiple Choice_ Please select where you heard about this job (Indeed, LinkedIn, Google, Other)
- _Short Response_ Can you tell us where you first heard about this role?

**Quality of questions-** This is useful if you’re looking to make sure that you’re asking the right questions to identify good talent. It’s also useful if you want to make sure that candidates feel heard and understood.
- _1-10 Scale_ I found the interview questions challenging.
-  _True or False_ I felt that the interviewers got a good sense of my skills.

**Briefing-** Does your candidate feel that they knew what to expect throughout the process?
- _True or False_ I knew exactly what to expect from each stage.
- _1-10 Scale_ I wasn’t surprised by any part of the interviewing process.

**Open ended response space-** This is less a type of question than a type of answer. Consider leaving room at the end of your survey to ask candidates if they have anything else to say. They may show you problems you’d never have anticipated!
- If I could change one thing about this hiring process, it would be...
- Is there more our team should know?
- What do you wish we’d done differently?

  
If any of these types resonate with you, you may need them, but don’t limit yourself. You may not even know what your blind spots are until you get candidate feedback.  
  
Keep in mind as you customize and write your questions that they need to be as clear as possible so that the maximum number of applicants understand them. Clarity will also help you avoid asking leading questions that push respondents to a particular answer.  
  
If you were to include all of these questions it would far exceed the recommended length. What information is most important to you? How much of that can you fit into the suggested length?  

## Aggregation using net promoter score formula

In contrast to a linear 1-10 scale, you may find that an NPS is a better fit for some of your questions. An NPS or “Net Promoter Score” is a metric that turns 1-10 scale ratings into a percentile. While those taking your survey will still see a “1-10” option on their end, you’ll be able to aggregate and calculate their scores into a percent on the recruiting team’s end.

NPS calculation refers to people who answered your question with a nine or ten as “promoters” and those who rated a 6 or lower as “detractors.” Simply, you find the NPS by subtracting the percentage of detractors from the percentage of promoters. (7 and 8 raters are called “passives” and don’t factor into the the final score.) The NPS score lets you know what percentage of those surveyed are truly delighted with your candidate experience - especially when you consider that the original concept came from the question, “How likely are you to recommend this to a friend?"

For instance, if you had 10 respondents, and 6 of them rated your candidate experience a 10, while 4 of them rated it a 1, your final NPS would be 20. (*60% promoters - 40% detractors = 20*)

NPS scores are extremely helpful when condensing many different survey responses into a single, digestible number, making it easier to quantify your overall candidate experience. And a digestible number makes it much easier to set realistic, actionable KPIs.

## The many facets of candidate experience

When we think of “candidate experience,” you’re liking to think of the specific interview process. But keep in mind that candidate experience begins with the job posting itself, and continues through every element of the hiring process.  

> "The further along an applicant gets in your process, the more likely they are to fill out your survey and provide high-quality answers." - Jeremy Lyons
  
Here are some areas you might consider incorporating into your survey, or even auditing to get a better sense of your overall experience:  

-   Language and accuracy of job listings
-   Emails
-   Glassdoor reviews
-   Website language (especially “about us” or “meet the team” pages)
-   Specific or niche industry review sites

  
As you craft your survey, don’t forget that first impressions and, by extension, your candidate experience, comes from more than just your interviews.  

## What else do you need to know?

As you form your questions and curate your survey length, there are a few other things to keep in mind.  
  
You’ll need to decide if you want your surveys to be identified or anonymous. Identified answers have the benefit of making it easy to track and follow up, but it may come at the cost of candidates not wanting to tell you their true thoughts (especially if they’d like to reapply later.) If they’re anonymous, candidates should be assured of this up front, and it may encourage them to be more candid and open.  
  
Regardless, allow applicants to skip any question they want. A required long-form answer may scare them off of being honest or may be too identifying for an anonymized survey. You want to encourage edge cases, like a candidate who accepts the job yet has strong feedback about the process.  
  
Decide which responses are helpful _after_ receiving them, not before. If you assume a swiftly denied candidate has nothing new to tell you, you rob yourself of the chance to learn something new. Give every candidate a chance to complete the survey.  
  
That said, be prepared to see some negativity from rejected applicants. It never feels good to receive bad feedback, but if you find similar sentiments across different applicants, you may find exactly what you need to change to make future reviews much better.  
  
This survey isn’t your only source of data about your candidate experience. Keep an eye on Glassdoor reviews, the language in candidate emails, and verbal feedback given to recruiters to see the whole picture.  
  
Finally, be sure you really put this data to work. “A lot of people have these set up,” says Lalane, “But they don’t have a clear process of sharing the responses within the department, with hiring partners, or implementing feedback where appropriate.” You’re doing hard work, so don’t waste it!  

## Start maximizing your success

Candidate experience can be complex, but measuring it doesn’t have to be. Ask questions thoughtfully and measure it with care, and the rest will fall into place.  
  
If you thought this article was helpful, [subscribe to our blog](https://www.ashbyhq.com/blog/#newsletter-form) for more.

To succeed in providing a high-quality candidate experience, you'll need to measure your process. Here's our complete guide on how to tackle your candidate experience surveys to get the results you need.

How To Effectively Design and Run Candidate Experience Surveys

We’re excited to be partnering with recruitment orchestration platform, [Dover](https://www.dover.com/)!

Dover automates your recruiting operations so that you can create an amazing recruiting experience. They evaluate candidates to find the ideal ones to fill your open roles, then deliver them right to you in Slack.

![dover in ashby](/images/ashby-__-dover-2.png)

With Ashby and Dover, your hiring process will be smoother than ever, as candidates move quickly through your pipeline, with less active work from your team.

To learn more, check out [Dover’s integration page](https://help.dover.com/en/articles/6238876-ashby-integration) or [Ashby University](https://www.notion.so/Dover-48f171bba34846e080f210e5935bb5a1).


Read on to learn about Dover and Ashby's new integration.

Ashby Has Partnered with Dover

“Candidate experience” is a pretty nebulous term. Firstly, it can mean a lot of different things to different people and, secondly, it's been used as marketing jargon for recruiting software in the last few years, making it even harder to to know what it really *means*.

To us at Ashby, candidate experience means that we want each candidate to feel as positive as possible about the time they spent interviewing with us. Ideally, they'll even feel inspired to recommend other candidates to interview with us, even if they didn't get the job!  

A great candidate experience will have a positive impact on your hiring process and your company brand. IBM conducted [a study with 7,000 candidates in 2021](https://www.ibm.com/downloads/cas/YMOARJJG) and found that:  

* A great candidate experience leads to **38% more accepted job offers**
* Candidates who had a good experience are **twice as likely to become a customer**
* Rejected candidates who had a great experience are **80% more likely to apply again**

We regularly hear very strong feedback on our interview process. We want to use this article to demystify “candidate experience” and share a few practical tips that will help you improve it, no matter the size of your team.  

![love for ashby in a candidate email](/images/ashby-love-email.png)

## 1. Be fast and responsive

If you only take away one lesson from this post, make it this one: speed matters in hiring. There are two main dimensions to this. The first is that a  quick response represents excellent service. If you’ve ever interacted with customer support, you’ve surely paid attention to how responsive they’ve been. You may have also noticed that responsiveness typically correlates very closely with the quality of service you receive.  

The second dimension of hiring speed is about candidate churn. In a competitive hiring market, hiring teams that move slowly will lose candidates that are mid-process with other companies.  

The rule of speed applies to every step of the funnel. You sent an outbound message and received a reply? Move to scheduling as soon as you can. You received a strong inbound application? Reply as quickly as possible.  

A responsive hiring process makes applicants feel more valued. An unresponsive one can even discourage the candidate's own engagement. You need to give responsiveness to get responsiveness.  

## 2. Communicate your process clearly at every step

Candidates want to know what to expect from your hiring process. A candidate left guessing might think that you're disorganized or uninterested, which leads them to proceed with other offers. Help them by making it clear what your interview and assessment process looks like from the start.  

At Ashby, we share an outline of the entire interview process with each candidate. This document highlights all the interview stages and who they can expect to meet at each one. We reinforce this by sending additional briefing details at every step of the process.  

As an early stage startup, you may occasionally make opportunistic hires and where you’re not as prepared as you’d like to be. That can be okay if you set the expectations with the candidate clearly. Let them know that the first one or two interviews will be more open-ended but that, afterwards, you’ll share a structured plan for the remainder of the loop with them.  

It takes a little bit of work to prepare the candidate-facing outline and email templates upfront, but it makes a *huge* difference for candidates. Providing clarity on the process also helps the candidate perform at their best, which means you’re going to get more clues if they’re a good fit from your interview.  

## 3. Let candidates know who they're meeting with and who their team might be

When you’re interviewing a candidate, they’re also interviewing you. They want to make sure your company is a good fit for them as much as you do, so find ways to help them out! The clearer a picture the candidate can get about what it would be like to work on your team, the more likely they are to move forward in the process.  

At Ashby, we tackle this in a few ways. Our [team page](https://www.ashbyhq.com/team) shows who new hires will be working with. It’s incredibly helpful to let candidates know who they’ll meet during each interview, and who might be on their team someday.  This eliminates surprises and allows the candidate to prepare better.  

We also share our content pieces (on [thoughtful communication](https://www.ashbyhq.com/blog/company/thoughtful-communication) and [time and productivity](https://www.ashbyhq.com/blog/company/time-and-productivity)) to highlight the more distinct aspects of our culture and give applicants a sense of how they’d be working if they were to join us.  

Together, these amount to a lot of high-quality information for a candidate, allowing them to prepare better for interviews and get a strong sense of our company culture. We’ve also noticed that having this content out there allows candidates to come to our interviews with much better questions about the team and work environment.  

## 4. Leverage your interviews as opportunities to sell

How you conduct your interviews themselves is, of course, a huge part of the candidate experience. This is your chance to interface with the candidate directly, and it gives them the best sense of what it’s like to actively work with you and your team.  

Challenging and relevant interviews are the best way to engage strong candidates. In the best cases you can highlight some real-world challenges your team is facing - this will give the candidate a sense of the type of problems they would get to work on. It’s also a great way to show, rather than tell, what your business’s main concerns and priorities are.  

You should ensure that all interviewers are well-equipped to speak about company culture and other common questions that candidates bring up. Have new interviewers shadow or take a small role in a series of interviews before leading them personally.  

Ideally, as you grow the company, you will introduce a more structured interviewer training program. This can help team members who are new to hiring, or hire infrequently, to feel confident and capable in the process. That confidence will be noticed by your candidates, who don’t want a nerve-wracking interview process thrown off by an interviewer asking confusing questions.  

## 5. Measure and iterate

The best way to ensure a strong candidate experience is to collect quantitative *and* qualitative data about your process from your candidates (ideally most of the ones you interviewed, whether or not you ended up hiring them.)  

You can create rubrics that align closely to the areas you care about most. We’ve kept our survey very short and focus mostly on expectation setting (ie “I was briefed well on what to expect during each interview.”) We want to keep the survey short enough that candidates won’t have to work hard to complete it.  

![ashby candidate experience rating](/images/ashby-ce-rating.png)

We’re always pleasantly surprised by how many candidates want to provide feedback on our process. It’s already provided some helpful insights to improve candidate experience even further. Treat every candidate as a chance to improve your candidate experience.  

## Make candidate experience your next big focus

All of this advice can be accomplished with the tools you are already using today. It’s all about making candidate experience a top priority, and giving each candidate the time, thought, and attention they deserve.  

If you want to learn more about how Ashby can help, feel free to [contact us](https://app.ashbyhq.com/startups/product), and [subscribe to our blog](https://www.ashbyhq.com/blog/engineering#newsletter-form) for more recruiting advice every other week.

Everyone wants to create an amazing candidate experience. But what does that really mean, and how can you maintain an excellent experience with an effective hiring process? We're diving into that question right now.

5 Simple Ways to Improve Candidate Experience and Close More Candidates

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.  


Ashby Has Partnered with Rippling

The Last Recruiter: How Startups Can Handle the Fierce Competition for Recruiters Today

Ashby Has Partnered with HiBob

How To Effectively Design and Run Candidate Experience Surveys

Ashby Has Partnered with Dover

5 Simple Ways to Improve Candidate Experience and Close More Candidates

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

Ashby Has Partnered with Rippling

The Last Recruiter: How Startups Can Handle the Fierce Competition for Recruiters Today

Ashby Has Partnered with HiBob

How To Effectively Design and Run Candidate Experience Surveys

Ashby Has Partnered with Dover

5 Simple Ways to Improve Candidate Experience and Close More Candidates

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