take home coding assignment reddit

The Essential Guide to Take-home Coding Challenges

by Jane Philipps

Introduction

Hi, I’m Jane. I wrote this guide because I want to help others with non-traditional backgrounds succeed on take-home coding challenges. Please read it, take notes, apply the material, and let me know about your results. You can reach me via email at [email protected] .

This guide is intended for anyone who has received a take-home coding challenge as part of the technical interview process and wants to attack it in the best way. This Essential Guide is a distilled version of a longer Ultimate Guide to Take-home Coding Challenges , which goes into much more detail and walks through an example challenge from start to finish.

So, if you’ve just received a challenge and are anxious to get started, start here, and then check out the full guide when you want to learn the material more deeply. Good luck!

Mistakes to avoid making when working on a take-home coding challenge

There are several mistakes you can make with take-home challenges. Some of these are small mistakes that are easily correctable, while others will leave you frustrated and unable to finish your assignment. I want to address these mistakes first, so when you’re given a take-home challenge, you know exactly what not to do.

Here are four mistakes you can make:

1. Time management and scope creep

2. Trying to learn too many new things at once

3. Making too many assumptions

4. Starting to code right away

Let’s look at each one in detail.

Time estimation is one of the hardest problems in programming, and even experienced engineers struggle with it. This plays into take-home challenges in a couple of ways.

First, some challenges come with “estimated time.” I usually ignore these, as they are rarely based in reality. Second, some challenges are open-ended. Many people, especially newer developers, will want to add tons of features because they think it will be impressive. Actually, it’s more impressive if you keep the scope relatively narrow, but finish everything you set out to do. In this situation, it’s better to do one thing really well than to do a million things poorly.

A good question would be: what counts as “going above and beyond” versus what counts as “scope creep?” My rule of thumb would be if your idea accomplishes or improves on the requirements of the assignment, that is likely a good idea, but if it seems tangentially related or “just cool,” it’s probably scope creep. But, as I describe later, always make it work first.

While a take-home coding challenge can be an excellent opportunity for learning, it is possible to take on too much learning. If you’re given a challenge where you must use a specific language or framework, but you’re not familiar with it, don’t add additional complexity by setting out to learn something new on top of that. For example, if you are using a new backend framework for a full stack app, stick to a frontend framework that you’re already comfortable with.

If your challenge is language/framework agnostic, but you’ve been itching to try out some new technology, pick JUST ONE to experiment with. Between reading the docs, getting your challenge properly set up, and getting used to any new syntax, you will have your hands full. Even learning one thing will eat up a lot of your time, so I would highly suggest limiting yourself to one new piece of technology per challenge.

As a developer, if you make too many assumptions, you are bound to build an application where the requirements are off, or the user experience is bad. When given a set of requirements for a take-home challenge, ALWAYS take the time to review the requirements and make sure you fully understand them. And, if you have any questions at all, always ask.

First, this shows that you are willing to ask for help when you don’t quite understand something, an important trait for a developer to demonstrate. Second, many companies will intentionally give you product requirements that are vague or not fully fleshed out in order to see how you react in these situations. They are actually testing your ability to make sense of requirements that may have gaps in them.

So, when in doubt, ask questions. Asking questions is also a signal that you are engaged and interested in the challenge.

One last mistake you can make is to jump in and start coding right away. I guarantee if you do this, you will regret it. Why? Two reasons:

Without proper planning, your code will suffer

Without first getting organized and making sure you fully understand ALL of the technical requirements, you may find yourself missing edge cases or rewriting parts of the functionality. I know it seems counter-intuitive, but you will actually SAVE yourself time if you plan ahead.

You will spin your wheels trying to get your app set up properly

Especially for newer developers, initial app setup can be one of the hardest parts of a take-home coding challenge. It’s not something you do every day, so it often takes some research and reading documentation to get reacquainted with the process and ensure you’re going about it in the best way.

So, there you have it — a summary of mistakes to avoid making. You’ll find that a lot of these are also applicable to your day to day work as a developer. In the next section, we’ll dive into further detail on how to get organized before you write a single line of code.

Get organized: how to plan before you write a line of code

Now it’s time to get to work! But, it’s NOT time to write any code YET.

Because, as you’ll see, a lot of the work actually happens before you write a single line of code. This may seem counterintuitive, but again — the more time you spend up front planning, the less time you will spend writing code.

So, now you have your coding challenge in hand and you are ready to get started with the planning process. Here are my six suggested steps:

1. Understand the requirements and ask any questions

2. Identify technical decisions you need to make

3. Technical design & whiteboarding

4. Test plan

5. App setup plan

6. Organize your tasks

First, you need to make sure you completely, absolutely, 100% understand the requirements of the project. If any part of the requirements are unclear, it is up to you to reach out to your contact and ask questions.

Sometimes companies will purposefully make their requirements vague, in order to see how you approach the problem. In these cases, it is always best to ask questions as it shows you are thinking about the problem and not just making assumptions and building an app to a vague spec.

Your next step will be to identify the technical decisions that you need to make. Making a list of all of your technical decisions up front and thinking about them before you’re in the middle of building your app will help you immensely. Not only will it cut down on time figuring things out later, but it will allow you to make big picture decisions up front, as opposed to trying to focus on both the big picture and the small details at the same time.

Now it’s time to plan out the rest of your app. For anything that you need to draw out, now is the perfect time to do that. Thinking through these decisions at the start serves two purposes:

• You’ll be able to reference these drawings and your original plan while you’re building your app. Then if you get stuck at any point, you can always come back to your notes.
• Later, when you are having a discussion with an engineer about your coding challenge, you can use these notes as a reference when they ask you why you made certain design or architecture decisions.

Once you’ve thought through and answered some of the bigger design and architecture questions for your challenge, the next step is research. If you’re planning to use a new technology or something you’re a bit rusty with, use this time to search for documentation and other resources.

Another very important step to take before writing a line of code is developing a test plan. Although you won’t get peer feedback on this test plan, it will help you look at the challenge from a different angle, making sure you’re meeting all of the requirements. By thinking through and writing out a test plan before you start coding, you are able to brainstorm possible edge cases that you should account for in your code and you will use this as a basis for testing your app later.

If you’re starting an app from scratch, figure out if there are any generators you can use to make your app setup easier and faster. Application setup is one of the hardest parts of take-home coding challenges, because it’s something that developers do rather infrequently. Best practices are always changing, so it’s easy to forget how to do. Also, when setting up an app with a specific combination of technologies for the first time, it can be challenging to get everything configured and working together properly.

If you are not using a generator, reading documentation and finding working examples are the two most important steps you can take. Being able to play with a working example and compare it to your own app will help you if you get stuck.

The last step before you start coding is to break down and organize your tasks. Breaking down your tasks is essential because it will help you stay on track as you’re working on your challenge, and it will give you a game plan for execution. Note that you shouldn’t be a perfectionist here, because there will always be unexpected bumps in the road.

Here is an example task list for a classic Tic Tac Toe app:

Some of these tasks can be broken down even further into smaller steps. For example, in order to implement the Tic Tac Toe gameplay with Javascript, here are some smaller tasks:

3. Writing tests: just do it!

Testing can be overwhelming, because there are so many different types of tests: acceptance tests, integration tests, and unit tests, not to mention test driven development vs. ad hoc testing.

Why should you include tests in your take-home coding challenge? It’s simple: your tests will make your submission shine.

First, adding tests shows that you know or are willing to learn another technology/framework. It also demonstrates that you take ownership of what you’re building, because you are taking responsibility to make sure it works. Testing also shows that you’ve considered edge cases, which many newer engineers often overlook.

Many companies take tests very seriously. Some will not tell you that they expect tests for your coding challenge, but will automatically reject you if you leave them out. Therefore, my recommendation is to write tests no matter what when given a take-home challenge. Not only will it make you a better developer, but for companies that were not expecting tests, you will stand out even more!

How do you go about writing a tests? First, create a plan. Here’s my 80/20 suggestion for how to come up with the right test cases:

1. Test the happy path

For the classic Tic Tac Toe example, the happy path is starting with an empty board and playing a game until X wins.

2. Think about variations on the happy path

A variation on the happy path would be if O wins, or if there is a tie game.

3. Think of edge cases

An edge case would be if a player tries to play a move in the same square more than once.

4. Test anything that is complex

The algorithm to find the winner is the most complex part of this example.

Here’s a sample test plan:

So, now it’s your turn. Think about your app and, as a baseline, think of 5–10 tests that you can write.

4. Make it work, then make it pretty, then make it fast

The title of this section sums it up pretty well, but when you’re working on building out your challenge, you should follow these 3 steps IN THIS ORDER:

1. Make it work

2. Make it pretty

3. Make it fast

When you’re given a take-home coding challenge, no matter what you do, the most crucial part of the challenge is to make it work. If you submit an app that has a nice UI, that will not matter if your app does not work or meet all of the requirements. Because building features to spec is a key aspect of your future job as a developer, you first and foremost need to focus on the functionality of your app and prioritize that above all else.

This is also key if you are low on or run out of time. Coding challenges can be a lot of work, especially if you want to go above and beyond to ensure that you make it to the next interview round. But, I can guarantee that you will not make it to the next round if your app doesn’t function properly or is missing some key components.

So, if you’re building a front-end app, this means focusing on making it work first, and styling/UI last. If you are building a back-end or full-stack app, focus on making it work before trying to refactor your code into the most elegant solution, and only then worry about optimization.

Even if you end up without any time to go back and refactor your code or style your UI, having a working app to present is more important. You can always talk to the interviewer about how you would improve your app, and refactoring some of your code might even be part of the next round of interviewing.

Make it pretty has two interpretations here. One is making the code pretty, and the other is making the UI pretty. Making the code pretty can be done in several ways. First, ensure indentation is consistent and your code is readable. Second, if you got something to work in a quick, hacky way, think about how you can refactor it to be a more elegant solution without overcomplicating it.

If you’re doing a front-end or full-stack challenge, you can also make the UI pretty as part of this step. Whether you use a library or write your own custom styles for your app, making the UI look good will show your interviewer that you’re taking the user experience into consideration when building a feature.

For some more front-end-focused challenges, you’ll be given a specific mockup to match. In these cases, making sure you’re detail oriented down to the last pixel is incredibly important. Part of your role may involve translating mockups from designers into user interfaces, so companies want to get a sense of how you approach those types of tasks.

Once you’ve made your app work, made it pretty (in the code, UI, or both), it may be time to make it fast! This is where understanding performance and BigO notation comes in handy.

You should take a look at your code and see if there are any areas where increasing the scale might be an issue. For example, are you using a double for loop somewhere? What if the arrays you’re looping over become super long?

If you think about these kinds of edge cases, you can then come up with plan to improve your code. Taking something that would have been running O(n) and making it O(1) will show that you’re thinking about performance when you’re building things.

How to make your code shine

When given a take-home coding challenge, many people think about how to build an app that works, but stop there. In this section, I’ll go over things an engineer reviewing your code will look for, so you can take your challenge to the next level and make your code shine.

When an engineer is reviewing your code, they will look for several different things. They will likely try to run your app to play around with it and see it working. After that, they will delve into the actual code, looking to see how you organized your app architecture and reading code in individual files.

There are several things you can do to make your code stand out. You want your code to be:

• Easy to follow
• Well organized
• Clean (properly indented, free of syntax errors and unnecessary whitespace)

These are the basics that don’t take much effort outside of mindfulness to get right. Now let’s talk about three of the more involved code style considerations:

1. How to name things

2. How to use comments effectively

3. How to format your code as you write it

Naming is one of the hardest problems in programming. One of the keys to naming things is to make sure you’re naming them in a way that another developer who is unfamiliar with the code can easily jump in and understand.

For functions, think about what exactly the function is doing. Is the function checking whether there is a winner on a row of a Tic Tac Toe board? Then a great name would be checkRow . Is your function handling a click on a square of the Tic Tac Toe board? Then a great name would be handleClick .

One quick tip: if you find yourself losing your flow because you keep stopping to think of the perfect name, split your process into two steps. First, write working code with any names (like foo , bar , and baz ). Then take a second pass through to improve them.

Adding comments can be a great way to capture what you were thinking at the time you wrote a specific piece of code. This can be useful to you, or anyone else who comes across your code in the future and needs to understand it, tweak it, or rewrite it.

Think of comments as adding clarity to your code. But, pay attention, because there is such a thing as too many comments.

Here is where you most likely do not need comments:

• When you declare a variable
• When you declare a function

Don’t do this:

The variable or function name should be enough to explain exactly what it does. If you need a comment to explain it, then you need to give it a better name!

Here are some examples of where comments can be useful:

• Technically tricky lines of code

First, let’s talk about HTML. Markup seems pretty self-explanatory, right? So, why would you need comments? Let’s say you have a really long HTML file with A LOT of <d iv>s. Comments can be a good way to signal which </div> tags close which sections.

In CSS, comments are a good way to divide up your styles if you have a lot of styles in one file. This way, when you come back to the code later and want to make a change, it’s easier to find the styles for that one section you need to update.

Comments in CSS are also very useful whenever you are hard-coding any math or adding an arbitrary number of pixels as margin, padding, and so on. Comments can be useful to explain things like this that are specific to your application.

One of the best uses for comments is when you’ve written code that is technically difficult or just not intuitive. You should always strive for simple, understandable code as much as possible. However, sometimes you will have confusing code — maybe you’ve chained a bunch of methods together or are using a complex regular expression — and it would help to explain what is happening in a comment.

You are almost done learning how to make your code shine! Just one more step.

I’m a STICKLER about formatting when it comes to code. And, it’s not just me. You’ll find that the best engineers also care about well-formatted, clean code. Why? First, it’s much easier to read! Coding can be really challenging, so when code is easier to read, it makes our jobs as developers that much easier. Also, writing clean code sends a message to your interviewers that you take pride in the craft of writing code, and for many teams, this is a big deal.

So, how do you make sure the code style sticklers will approve of your code? There are a few simple tricks you can use as you’re working through your coding challenge to ensure the end result comes out clean and you don’t have to spend time at the end reformatting everything.

• Choose tabs or spaces and be consistent across your entire application (i.e. no 2 spaces in some files, 4 spaces in others)
• Indent your code properly as you go so that it stays readable and isn’t all over the place
• Get rid of trailing whitespace! Whitespace can sometimes wreck havoc, so it’s best to just get rid of it as you write your code.
• Keep your syntax consistent throughout your entire app. If you’re using a linter, this will be easier, but requires setting one up. If you don’t have time to set one up, pay attention. Don’t use ES5 in some places in your app and ES6 in others. Pick one and stick with it!
• Remove unnecessary logging and debug statements when you’re done using them! Unless logging is part of your application, you’ll want to remove any temporary statements you were using while building your app.
• Always leave a newline at the end of every file

That’s it! It’s pretty simple, and once you’re in the habit of doing this, not only will your code be easier for you to read, but it will also be easier for others to read and maintain. Many new developers haven’t been exposed to very much code maintenance, but trust me, when you have to clean up code someone else has written, you will be more thankful if it was neatly organized to start. Pay it forward!

Here’s an example of badly formatted code:

Here’s an example of the same code, but cleanly formatted and MUCH more readable:

How to take your challenge to the next level

Here are 3 ideas for how you can take your coding challenge to the next level:

2. UI/UX design (for front-end or full-stack challenges)

3. Data validation and error handling

Not all coding challenges come with bonuses, but if yours does and your goal is to get a job offer, do them! Why? It’s pretty simple. If you go above and beyond in your coding challenge, it will show that you will go above and beyond once you’re hired at this company. Completing bonus requirements is a high competence trigger for the interviewer.

Some front-end or full-stack challenges will mention UI/UX design as a bonus, but if they don’t, putting in some effort to make the UI look nice and be easy to use will go a long way. You can either go the route of adding your own custom CSS or plugging in a library or two to help make your styling even more painless. If you use a library, just make sure that you understand how it works enough to explain how you’ve used it.

Data validation and error handling are key components in production apps. Adding either one of these (or both!) to your challenge will help make it stand out. Many developers who are new to coding and haven’t worked in a production codebase before don’t have a ton of exposure to either of these, so if you add error handling for edge cases it will show that you thought through a lot of different situations.

How to write an awesome README

You may be done writing code, but you’re not done writing yet — it’s time to write your README.

Why you should include a README

READMEs are incredibly important, both for professional developers and for job seekers working on take-home challenges. Including a README shows that you care about documentation.

Documentation helps spread knowledge across teams and serves as a supplement to your code. Having documentation for your take-home challenge ensures that anyone else (or future you) can jump into your code with a clear understanding of what you’ve built without any guessing games.

Your README is also the KEY to making sure that everyone reviewing your challenge has the most painless experience possible. Finally, your README is a way of proving to your reviewer that you successfully met the requirements of the challenge.

How to write your README

Writing a great README is not hard, and you will stand out a great deal from the other applicants with one. Here are the five sections I’d recommend you include:

1. Installation instructions

2. Discussion of technologies used

3. A section demonstrating that you met the requirements

4. If there are bonuses, a section demonstrating that you met them

5. For algorithms and data structures, time and space complexity

When writing your README, don’t make any assumptions. Write out all of the steps to run your app locally and test them yourself. This includes cloning the repo from Github, running installation commands, and starting up a server. Also, make sure to include versions of software that you are using. This will ensure that the developer reviewing your code has a seamless experience setting up and running your app, and if they do happen to run into any trouble due to versioning, they will have all of the information they need right there in the README.

This section is as simple as it sounds — make a list of all of the technologies you used including frameworks and libraries. If you had to find a library for a specific piece of functionality in your take-home challenge, mention it here and include a link to the docs.

Usually your take-home challenge will come with some sort of requirements spec, so make sure to include a section in your README where you describe the requirements and how you met them. In some cases, you can take the product spec you were given and write a short explanation of how you met each requirement in a list. In other cases, you can simply include a short paragraph explaining how you satisfied the requirements. It’s totally up to you how you do it, just make sure you include it.

Similar to the requirements section above, you’ll want to highlight any bonuses you completed while working on the take-home challenge. If you attempted a bonus, but couldn’t quite get something to work, then the README is also a good place to address that. You can discuss the approach or approaches you tried and what worked or didn’t work.

If you had to write any algorithms or data structures as part of your take-home challenge, it’s helpful to include the space-time complexity of your final algorithm. This can be done in Big O notation.

One final word of advice: write your README in markdown so it looks nice! This will demonstrate that you know (or are willing to learn) another language that will come in handy as a full-time developer.

Here is an example README for a Tic Tac Toe app:

Final steps before you hit send

Now that you’ve written your README, you’re almost ready to hit send! Before you do that, take the time to double check all of your work using the following checklist:

• Re-read the take-home challenge instructions to make sure you didn’t miss any requirements
• Review your app’s code to ensure that it shines
• Run your app’s automated tests and make sure they are all passing
• Test your app manually and make sure everything is working properly
• Test your app installation instructions from your README
• Start an email draft and copy your README into it for convenience
• If requested, make sure to attach a zip file of your code
• Write an email to your contact at the company

Your email can be short and sweet — I always like to highlight something I enjoyed about the challenge or something I learned. Here’s an example:

Note that you should only mention interviewing with other companies or offer deadlines if either is actually the case. I feel you should be honest and candid about your situation and maintain leverage for a potential future compensation negotiation at the same time.

Now, finally, hit send!

I hope this Essential Guide was helpful and you learned something that you can apply to a take-home challenge or in your day-to-day work. If you have any comments, questions, or other feedback, please don’t hesitate to reach out. You can reach me at [email protected] .

Also, if you enjoyed this guide and want to learn more, feel free to sign up for my email list:

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Take-Home projects quick start

Last updated on May 6, 2024 • Disponible en Français

Interview’s take-home project feature allows you to set up a pad with technical questions, and send a link to the candidate for them to complete the project on their own time.

You can also include test cases with your questions. This allows you to provide the candidate with a set of tests that their code must pass. This helps a candidate better understand the desired solution you are looking for, but also allows you a chance to see how complete a candidate’s solution is.

Setting up a take-home project

1. From the left navigation select “Question Bank”. Once on the next page, you will see a new screen showing your library of questions. You have two options for creating a take-home project.

• To create a take-home test from an existing question , select a question from either 1) your company under Organization Content or from 2) Interview’s example list under CoderPad Examples and then select Create Take-Home .

• To create a new custom take-home project question from scratch , click Create Question and follow the prompts:

📃For more information on creating questions, check out the tutorial here .

2. Once you locate the question you want to use, you will select Create Take-Home . You’ll then be taken to the Create Take-Home Pads screen.

Here you’ll need to select the time limit (the default is 2 hours) and then add the names of the candidates you’d like to generate a link for. You can manually enter their name or drop in a file (.txt or .csv) with a list of candidates.

Once you click on Create [N] Pads , you’ll be presented with a screen that will generate the take-home test pad links for each candidate:

✅For more details on creating a take-home project pad, you can check out the full tutorial here . If you want create a  single URL  that will load a specific take-home project question for any number of candidates, check out our Public take-home project guide here .

Adding Test Cases

✅ At this time you cannot utilize test cases for multi-file framework language questions.

Test cases are a way to verify a candidate’s solution against a set of return values given a set of inputs.

You can add test cases to your take-home assessments when you create the question for the assessment in the question bank; additionally you can add them by editing the assessment question.

✅To learn more about test cases, what a function signature is, and how to add and remove test cases, please see our docs on test cases .

Reviewing results

Interview tracks every single keystroke of every participant’s solution within a pad during the take-home project. This is useful to review during a debrief to easily recall how a candidate reached their solution.

This playback is available once the candidate submits their project, or when the timer for the project runs out (whichever comes first). To access the playback, simply navigate back to your Pads List on your dashboard, find the pad you want to review, and click on Review :

The playback screen will look similar to this:

The playback screen has three tabs that you will find useful:

• Test Cases , which lists the results of the test cases you created for the take-home
• Program Output , which shows the printed output of running the candidate’s code.
• Private Interviewer Notes , which provides a space for you to take notes about the candidate’s work while reviewing the playback.

How to Create a Great Take-Home Coding Test

Anton Fenske / Twitter · LinkedIn

Programming skills tests are an essential component of hiring developers. Take-home coding challenges provide a convenient way to assess tech skills and test developers because they are asynchronous and don't put candidates under pressure.

A failure to consider some fundamental aspects could lead to incomplete tests, wasted time for both parties, and incorrect assessment of candidates' results.

In this post, we'll cover the basic rules for ensuring that your programming skills test achieves its primary goal, i.e., how to test developers’ skills in order to identify if they have the necessary technical skills and problem-solving required for the job.

"First, solve the problem. Then, write the code." — John Johnson — Programming Wisdom (@CodeWisdom) August 16, 2021

What Are Take-Home Coding Challenges?

Take-home coding challenges are small projects you are assigned by your potential employer as a means of assessing your technical skills and knowledge. Generally, the task is moderately complex and might require a few hours to complete.

The employer sees what you will be able to accomplish in a less time-pressured setting than in a whiteboarding interview. By doing this exercise, you are able to research and document, as well as demonstrate other skills, that you wouldn't be able to show on a typical whiteboard.

In theory, the take-home challenge will allow you to work in a relaxed environment in which you are comfortable. This means that you are likely to be able to do your best work.

With take-home tests, the main challenge is that people have to do them outside of work hours. Therefore, you have to be mindful of the following constraints:

• Candidates are often short on time, so they might not finish the test.
• Take-home tests require a longer feedback loop. Since your candidates are going through several interview processes, you might lose them to someone else.
• Take-home challenges may also be viewed as "free work".
• Among the mistakes hiring managers make are tests that are too long and interviews that do not offer feedback.

Here are a few examples of what developers think about live challenges versus take-home tests.

Live coding challenges are the toughest part of interviewing for most people Here's a summary from my latest blog post on @frontendeval about how to ace them: — Mike Chen🌱 (@genericmikechen) February 17, 2022

Just had the initial HR phone screen for a job. When asked about the interview process & coding challenge she said “the coding challenge will be take-home. We don’t believe in live-coding challenges because that’s not what you’ll be doing on the job.” And I’m crying tears of joy. — hannahrosecodes (@hannahrosecodes) November 18, 2019

Is There a Solution?

Sadly, there is no guarantee that all your candidates will complete the coding skills assessment, or that you will have enough time to select the best candidates.

Nevertheless, if you follow these tips, you'll maximise your chances of getting the best results on your developer hiring tests.

How to Test Coding Skills

First, define the main assessment objective and make your exercise revolve around it. The following questions should help you:

• What experience levels do we target?
• What tech skills do we want to assess?
• Do we only want to screen candidates or do a full tech assessment?
• What competencies can we assess automatically using auto-tests, and when would we need a manual code review?

The second step is to create a clear task description. Until now, the following structure has proved successful at Alva Coding Tests:

• Introduction - provides a general description of the task at hand.
• Getting started instructions - helps the candidate get started quickly (e.g., describes the setup, how to run tests, describes external dependencies, and so forth).
• Expectations - describes what the candidate should focus on, in priority order, and what the assessor’s expectations are in terms of what they’re required to do and what skills they will need to showcase.
• Ways to get help - describes how a candidate should proceed should they get stuck during the assessment.
• Time estimate - helps the candidate effectively plan their time before starting working on the task.

Here is an example of how it could look, based on one of Alva Coding Tests' real-world coding tests :

Finally, your coding test can include automated tests that candidates can run by themselves on their local machine to confirm whether their implementation satisfies the acceptance criteria.

Once your candidate volumes have increased, you can also use the auto-test results to vet your candidates with no developer effort on your side.

Reduce Friction

Stick to the process developers use every day:

• Instead of sharing your take-home challenge as an email/Word doc/ zip file/, use a Git repository (ideally, use GitHub as most developers already have an account there).
• Instead of asking them to send you an email when they are ready, tell them to create a Pull Request.
• To avoid losing emails, ask them to create a ticket (e.g., GitHub issue) instead on their repository whenever they run into issues.
• Pre-upload a project template (or templates if you expect submissions in multiple tech stacks) so that your candidates don't waste time setting everything up from scratch. You can use the Alva Coding Tests import script that supports a number of tech stacks.

Define a Standardised Code Review Scorecard

As humans, it's easy to get caught up in biases when looking at someone's code.

To ensure no bias creeps in, create a code review scorecard that includes the following:

Embrace Continuous Improvement

In the beginning, you'll likely have some teething problems with your take-home challenges. What's worse is that not all your candidates will be vocal about it.

To ensure that your programming skills tests are up to standard, use this 2-step rule:

• Add the following to the challenge criteria: "Describe one thing you'd improve about this coding assessment".
• Once there is a good suggestion, implement it right away.

Following this rule will save your tech interviewing team hours of future process revamping and result in hiring great candidates.

Taking action afterward not only helps you learn valuable things about your candidates (their problem-solving abilities, communication skills, teamwork, etc.), but it helps you perfect the candidate experience as well.

If you give candidates feedback, you ensure that they understand your decision and learn something for their next application. A candidate who has spent hours on a task is incredibly disappointed to get rejected without explanation. Even worse, they might not hear from anyone at all.

Developer hiring is hard. But it doesn't have to be. If you follow the coding test for hiring principles above, you will already be way ahead of most tech recruitment processes.

A skills-based approach is the most effective way to identify unqualified candidates early on. It is now an effective way for hiring teams to assess their candidates.

By doing this, you will not only save time, but you will also gain a deeper understanding of how your candidates think, solve real-life problems, and apply this to their roles.

Never miss out on great talent again

" We saved hundreds of hours with the Alva Coding Tests' out-of-the-box technical interview solution that integrated seamlessly with our existing setup." — Andreas Gabrielsson, Head of Engineering at Alva Labs.

DEV Community

Posted on Sep 6, 2021

6 Tips To Beat The Take Home Coding Test

Take home coding tests are seen by many as the ideal alternative to stressful in person live tests. While that may be true to a certain extent, it doesn't mean that there aren't pitfalls to be wary of, here are my 6 top tips for making sure you crack your next take home test:

• Make sure you know exactly when the test is due , they might be casual about it but see if you can nail them to a deadline. This would be expected in a job and so you should do the same here, it actually works in your favour as well, if they want it done in 24 hours and you had been thinking "I'll get to it at the weekend" you can now re-asses.
• Don’t be afraid to ask questions about it if you need to . It’s unlikely that they have covered off literally everything in the spec. If you are short on time and just want to get started then add a comment to the readme about an assumption you made that saved you asking a question.
• Add a readme, explain your thinking and approach . At the end of the readme add some notes on what you found challenging and how you would improve it. Make sure the readme contains all steps required to get the project up and running so that they can run it locally if they want to.
• Ideally host it as a Github repo and send them the link to it . Emailing projects with many files zipped up can be flaky.
• Flag best practice breaches . If you go down the Github route and have passwords or API tokens in your code then highlight in the readme, or in a comment, that you know this is bad practice but for the purposes of the test you have included them. If the test specifically tells you not to do this then don’t, however that’s getting beyond what I think would be expected of in a reasonable take home test.
• Don’t solve more than they ask for , the idea here is that you have been given a task to do to assess your coding skills and your ability to follow instructions. By all means do a good job but this isn’t the time to “express yourself”.

There you have it, everything you need to make sure your next take home test.

If you want more like this head over to CareerSwitchToCoding.com and sign up to the mailing list for a free chapter from my book 😀

Top comments (0)

Templates let you quickly answer FAQs or store snippets for re-use.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Top Automated Testing Tools for 2024: A Comprehensive Guide

Jennifer Smith - Aug 2

Understanding Immutability in JavaScript: A Dive into Mutable and Immutable Data

Brandon Collins - Aug 2

Redis Singleton in Your Express Application

hoangbui - Aug 6

So You Want to Be a Web Developer? Here's What You Need to Know!

Rahman Karim - Aug 15

We're a place where coders share, stay up-to-date and grow their careers.

• For Candidates
• Request a demo Free trial

Take-Home Coding Challenge Examples That Will Change the Caliber of Your Applicants

Coding tests greatly increase the quality of applicants who advance into the final stages of technical hiring. They effectively distinguish talented candidates from unqualified applicants early on in the interview process. Coding tests also reveal a lot about candidates’ working style, efficiency, and communication skills. Take a look below at several take-home coding challenge examples that you can use in your next technical interview. 

Take-Home Interview Advantages

Technical interviews usually begin with screening candidates and selecting those who possess the required qualifications on their resumes. Then, candidates go through screening questions that plumb the depth of their skills and experience. Some of these questions might include:

• What relevant technical qualifications and training certifications do you have?
• Do you have experience using...?
• How do you handle criticism or feedback from teammates?
• How would you explain [a technical concept] to a non-tech co-worker? Do you prefer to work independently on a technical problem or figure it out with the help of others?

‍ Such questions probe candidates' deeper understanding of their subject area and interpersonal skills. After this stage, the candidate proceeds to the technical assessment portion, where they solve a challenge live or on record in their own time. Take-home interviews are particularly useful for candidates who are not comfortable with a live test. Likewise, take-home interviews allow engineers and team leaders to review a candidate’s work in detail.

Take-Home Coding Challenge Examples

Take-home challenges depend on the position level in which candidates are applying. Here are a few examples:

Data Structures

• Array: Find a pair with the given sum in an integer array using sorting or hashing.
• Trees: Write a function that deletes a given key within a binary search tree.
• Matrix: Find the shortest move sequence of a knight on a chessboard from its starting position to a destination square. 
• Linked List: Using two lists containing increasing numbers, write a function that merges them into one with numbers in the proper increasing order
• Dynamic Programming: Write a function that divides a given set of integers into two partitions with equal sum

Algorithm Questions

• Implement the Quicksort partitioning algorithm in your preferred language
• Design an algorithm that inserts a node in a sorted list/linked list
• Write an algorithm that deletes a node in a singly linked list
• Write an algorithm that interchanges two numbers in Java without a temporary variable  
• Design an algorithm that counts the number of leaf nodes in a given binary tree 

Web Development

• Build a sample website for your favorite TV show
• Recreate the layout of our flagship product page
• Build a web page with social widgets
• Design a sample mobile app for one of our services using jQuery Mobile 
• Design a portfolio website using your preferred language

Software Engineering 

• Design an app that tracks system bugs
• Develop a sentiment analysis system for a product's rating and reviews
• Design a website chatbot for answering basic queries
• Develop a mobile checkout app with QR code
• Design a web app for scheduling employee shifts

Data Science

• Create a time series forecasting model that predict store sales using historical sales data
• Build a credit score prediction model using a credit scoring algorithm
• Estimate the future price of a product using market trend analysis
• Predict the sale price of a house using given datasets

After the Test

Team leaders and engineers can build on the take-home challenge by inviting the candidate to a live interview after the challenge. This is where the applicant and interviewer go over the code together and discuss important aspects of the test, such as the candidate’s approach to problem solving. Team leaders can give feedback on the output and even code with the candidate in real-time to see how they collaborate with teammates.

Take-home coding challenge examples focus the hiring process on skill and technical expertise. It gives candidates ample time to think and accomplish what they want to do, especially if they are not comfortable being put on the spot with a live test. It also gives team leaders and interviewers a chance to examine the output in detail and make better-informed decisions regarding candidate selection. Lastly, senior engineers and team leaders can build on the take-home coding challenge by providing feedback, asking about candidates’ methodology, and doing a coding exercise together. 

Hire High-Quality Tech Talent with Filtered

Filtered clarifies the technical hiring conversation with skill-based assessment. Our platform offers a range of take-home coding challenge examples covering full-stack, SQL, data science, DevOps, and more. Our technical tests support 30+ languages and are designed to cover multiple skill levels within major engineering disciplines. What’s more, our platform is equipped with robust fraud detection so that you can hire technical talent anywhere in the world with confidence.

Filtered is a leader in skills-based, data-driven recruiting technology. Our end-to-end technical hiring platform enables you to spend time reviewing only the most qualified candidates, putting skills and aptitude at the forefront of your decisions. We’ll help you automate hiring while also applying objective, data-driven techniques to consistently and confidently select the right candidates. To get started, contact our team today or register for a FREE demo . 

Search Our Blog

Stay in the know

We use cookies on this site to enhance your user experience..

By clicking any link on this page you are giving your consent for us to set cookies for basic site tracking, user and session management. Please review our updated privacy policy before interacting further with this site.

edition e1.0.8

You’re reading an excerpt of The Holloway Guide to Technical Recruiting and Hiring , a book by Osman (Ozzie) Osman and over 45 other contributors. It is the most authoritative resource on growing software engineering teams effectively, written by and for hiring managers, recruiters, interviewers, and candidates. Purchase the book to support the author and the ad-free Holloway reading experience. You get instant digital access, over 800 links and references, commentary and future updates, and a high-quality PDF download.

A take-home assignment (take-home or takehome) is a coding task given to technical candidates to complete on their own time. Candidates are typically given a day to several days to complete a take-home.

​ controversy ​ Take-homes are controversial. While there are many pros for the companies assigning them, they are less valuable in terms of the candidate experience. Nonetheless, they do have some advantages for candidates.

Benefits of Take-homes

​ candidate ​ Take-homes remove a lot of the stress associated with onsite challenges. Candidates get to use their own tools and work in the style they would if they were on the job. They can review and iterate on their work, take time away to think or rest, and rewrite. One senior engineer put it this way: “Most employees ‘take home’ their work if you think about it. You get work, you go away and think, you do it, you sleep, you come back and review it. That’s how our jobs work.”

For companies, take-homes have arguably the lowest false negative rate of any interview format—“the truest signal,” as Scott Woody, former Director of Engineering at Dropbox, put it to Holloway. A few factors account for this:

Take-homes give the candidate enough time to do the work in an environment that they’re comfortable with, so you eliminate the noise of a whiteboard interview .

It’s very hard to hide weaknesses in coding ability in a take-home, and follow-up conversations can tell you almost everything you need to know about how a candidate thinks through problems.

Follow-ups also allow you to weed out and correct for any negative signal or false signal—for example, if a candidate cheats, talking through their work will help you figure that out.

Follow-ups are an important part of the take-home evaluation; in this respect, take-homes are the first step of a larger conversation. A good take-home will mimic assignments the candidate might reasonably be asked to do on the job and will give you practical signal on their abilities, creativity, and style.

Here’s how a sample assignment might progress. Let’s say the take-home is something like “Build a simple web-based calculator app” or “Build an AI version of Tetris.” When the candidate returns, you might read the code and interrogate it together, bringing the initial asynchronous assessment into a synchronous evaluation:

You ask the candidate to critique their work.

You may then ask them what they would do given another 20 hours; or say, “How would you invest 10 more hours on this?” Questions like “What feature would you remove?” and “What feature would you add?” will further refine your understanding of their work.

An additional useful question is, “What shortcuts did you take, and why did you think that was the right shortcut?”

Downsides of Take-homes

​ caution ​ The major downside of take-homes is the time commitment they require. Because the market is so competitive, asking a strong candidate to give up their weekend for a take-home can lead them to drop out of your process. Senior candidates may feel that being asked to do a take-home is a waste of their time. For these reasons, take-homes usually make sense further along in the funnel . They require a lot of engineering time and investment from interviewers and candidates, so they aren’t ideal for screening. Some companies opt to pay candidates for the time they spend on these assignments, but this doesn’t always make a difference. A senior manager at Dropbox told us that before the company pivoted from take-homes, 20% of candidates would simply not complete them. Less-competitive candidates were more likely to complete the assignment, because they didn’t have competing offers. The pass-through rate was close to 10%. If you’re asking candidates to invest 15 hours, and their chance of passing through is 10%, the value asymmetry is strong.

Despite the high signal achieved, interviewers, too, spend hours of their time designing take-homes, scaffolding in multiple languages, and reviewing code, and with such a low pass-through rate, this hardly pays out.

​ danger ​ The other major con of take-homes is that they explicitly discriminate against people who have families or adverse financial situations, or who work more than one job. If these candidates are in the hiring pipeline at more than one company, they may receive multiple take-home assignments at once, making them impossible to complete, and this may cause the candidates to drop out of your process.

Take-homes also open up the possibility that a candidate may cheat by asking friends to help or collaborate. Additionally, with a take-home, you’re asking candidates to work in a vacuum, which doesn’t match to most work environments, where you’re hopefully able to ask questions and get feedback as you progress.

​ caution ​ Take-homes are difficult to timebox and thus difficult to assess fairly. If candidates have been given 48 hours to turn in an assignment, you might be comparing candidates who spent 40 hours with those who spent only 2.

One way to avoid this false signal is to pay people an hourly rate for the assignment; but candidates can lie, either saying they worked more hours so as to receive the pay or fewer hours because they want to look impressive.

There are situations in which the pros of take-homes outweigh the cons. Smaller companies may find it easier to assign take-homes than to expend the time and resource investment in a longer pipeline, where multiple interviews would be needed to get the same signal. Younger engineers trying to break into the industry may prefer take-homes because they provide a chance to demonstrate skills they haven’t yet had a chance to prove on the market. If there’s a candidate you haven’t gotten clear signal from yet, adding a take-home to their pipeline will usually tell you one way or another whether the bet will pay off. Scott Woody, former Director of Engineering at Dropbox, told us that people who tend to shine on take-homes have nontraditional backgrounds: “They’re hackers, or they never took CS in college, and they’d fail out of our normal process. But we can see they’ve been doing all this practical work on the side, so let’s give them this practical thing and they’re going to build something singular.”

Take-home Tips

Using a tool like Takehome.io can help with timeboxing take-homes. It might seem like the option of timeboxing would help solve a lot of the cons of this format, but many engineers hold the opinion that time limits introduce further artificiality that compromises what could otherwise be a clear signal. There are tradeoffs any way you approach it.

If you do choose to give take-homes, it’s important to be clear with the candidate that the results will only be used for evaluation and not to produce work for the company. You might also provide an upper bound on the amount of time a candidate should spend on the take-home. When sending candidates the assignment, it’s important to let them know what it is that you will be evaluating—the code? the creativity? the speed? This will help ensure that they don’t waste time on something that won’t translate as much to the assessment and the eventual job. You likely also will want to avoid noting things as nice-to-haves unless they are truly necessary for the assessment.

One idea worth noting to help make the candidate experience better is to replace the take-home with a project that is done in the office during the onsite. Such a project still requires a logistical burden, but has the benefit of feeling like a symmetric exchange of time, particularly if it replaces multiple interview questions. The goal is to mimic the benefits the take-home has for candidates—let them work alone.

​ candidate ​ Understanding the reasons why a company might choose a take-home problem can help candidates prepare. This guide from Jane Phillips has a host of practical suggestions for tackling take-home coding challenges , along with an FAQ on common scenarios, like needing more time or what to do if you’re not familiar with a language or framework in the take-home problem.

Prior Work Assessment

Some companies choose to ask candidates for past work samples rather than asking them to write code (though you can do both). The nice thing about this approach is that it allows you to see something that the candidate actually did in a real-world setting. However, it can be difficult for many candidates to provide this kind of work sample if they don’t have an open-source presence, and evaluating these work samples may take more time and require a great deal of interviewer effort to evaluate. Prior work assessments can be:

Synchronous. The candidate walks the interviewer through a completed project or portfolio.

Asynchronous. The candidate sends work to the interviewer for them to review, and/or the interviewer reviews the candidate’s open-source projects (likely on GitHub).

Real-world coding interviews for every hiring process

Identify great candidates using real tasks, not brainteasers. Get an accurate measure of your candidate's abilities and hire the right person for the job.

Real tasks, not brainteasers.

Take-home Challenges

Our library of real-world tasks gives you an accurate measure of every candidate’s coding skills, whilst providing them with a fair and considerate interview experience.

We've found with CodeSubmit, the process isn't just simple for candidates, it's also giving our hiring managers a better idea of potential job performance.

Pair programming, reimagined.

CodePair™ Live Coding

CodePair makes it easy to set up a powerful shared coding environment and work through coding problems with your candidates. Your technical interviews have never been more effective.

Screen candidates early in the hiring process

Bytes Screening Tasks

Our Test-Driven Development (TDD) approach to screening invites candidates to write code against predefined tests, ensuring a seamless evaluation of their problem-solving and coding prowess.

Integrates with your ATS

Integrate with Greenhouse , Lever , Personio , and Zapier , and hundreds of other tools to track and manage all your candidates in one place. Stay on top of interview results by receiving on-time and actionable notifications.

Get the Reddit app

CSCareerQuestions is a community for those who are in the process of entering or are already part of the computer science field. Our goal is to help navigate and share challenges of the industry and strategies to be successful .

Take-Home Assignment Plus Live Coding Assignment?

By continuing, you agree to our User Agreement and acknowledge that you understand the Privacy Policy .

Enter the 6-digit code from your authenticator app

You’ve set up two-factor authentication for this account.

Enter a 6-digit backup code

Create your username and password.

Reddit is anonymous, so your username is what you’ll go by here. Choose wisely—because once you get a name, you can’t change it.

Reset your password

Enter your email address or username and we’ll send you a link to reset your password

Check your inbox

An email with a link to reset your password was sent to the email address associated with your account

Choose a Reddit account to continue

Here's What the Hiring Manager's Actually Looking For in That (Dreaded) Take-Home Assignment

Just when you think the you’ve nailed your interview, you hear this dreaded line:

As the next step in the process, we’d like for you to complete a short take-home assignment.

Suddenly, instead of doing a celebratory dance that you’re one step closer to the position, you’re thinking, “I’d better cancel my dinner plans for tonight, and tomorrow.” Quickly followed by, “Oh no! This is where they find out I’m a complete fraud !”

Before you panic about the assignment that’s standing between you and your dream job, take a deep breath and stop beating yourself up over it. It’s not exactly what you think—seriously, I used to assign them to candidates all the time, so I know.

Here are a couple things you need to understand about what hiring managers are actually looking for in this project.

Don’t Agonize Over Finding the “Right” Answer

If you haven’t been hired yet, you shouldn’t be expected to know all the nitty-gritty details about a company. And hiring managers know this!

Sure, the assignment is a great way for the company to see how you would address a real business problem, but it would be unrealistic to expect even the most qualified candidates to present a solution that could be implemented immediately. Again, I can’t reiterate this enough: The person who assigned this is completely aware of that fact!

And because of this, you shouldn’t stay up late focusing only on getting the “right” answer. Odds are, there isn’t only one right answer.

Depending on your expertise, this might manifest itself in a number of ways. If you’re a programmer who’s being asked to write some sample code, the hiring manager is going to be way more interested in how quickly you identify the mistakes you’ve made. And before you say, “Well, I won’t make any mistakes,” don’t worry, you will. The same goes for those of you who are writers, marketers, or sales people. You will mess up somewhere in the assignment.

When you’re brought in again (fingers crossed) and asked to discuss where you went wrong, be open and willing to find and acknowledge any errors. Bonus points if you can bring quick fixes and solutions to the table as well. One way to prepare for this conversation is to look at your take-home test before going back in to the office—you’ll almost always find a spot you’d like to revise.

Don’t Psych Yourself Out

How many times have you looked at the email outlining the requirements and thought to yourself, “If I can’t do this, how would I possibly excel in the actual job?”

Here’s the thing, though: If you weren’t capable of doing the job, you wouldn’t have been sent home with it in the first place.

In fact, the take-home assignment should actually be a huge boost to your confidence. When you’re asked to complete one, it’s a clear indication that the hiring manager’s excited to see how you’d tackle a problem similar to one the organization’s been dealing with. In other words, the company’s struggled with the issue in the past and would love to hear your input!

Of course, depending on exactly what you’re being asked to complete, you’ll want to take some additional precautions before diving in. But the mere fact that you’re moving to this step is a good indication you’re a top contender.

Keep in mind: The person who will review this assignment’s often juggling multiple calendars, interviews, and never-ending inboxes. No one adds more to his or her plate for fun. You’re in a great place!

Don’t Forget This Is Just as Much for You as it Is for the Hiring Manager

Most job seekers can’t count the number of times they’ve been told they should be interviewing a company as much as a company interviews them. There are a number of reasons for this, but the biggest reason is to make sure you actually want to join the company (how many of us have taken jobs just because we’ve needed them—only to regret it on day one?). However, as tired as you might be of hearing this kind of advice, it also applies to the assignment:

If you find it boring or not suited for your skills, don’t ignore this.

While it won’t be completely indicative of what your day-to-day will be like, many elements of it are probably pretty close. It’s OK if it’s challenging, but it’s not OK if you’re miserable from the minute you start it.

Back in my recruiting days, I worked with each hiring manager to develop take-home assignments that would give us clarity on whether or not a candidate would thrive in similar challenges. We didn’t always expect people to nail the assignment. In fact, in some cases, we liked a candidate so much, we just wanted to make sure he or she met our deadline. But, we did try to give the person an idea of what to expect. If that doesn’t line up for what you’re hoping to do in your next role, take that into consideration, especially if you’re ultimately offered the job.

Yes, an interview assignment can be daunting, but it’s nothing to lose your mind over. Take a deep breath, remind yourself that you can do this, and remember that while it’s an important piece of your candidacy, it’s not the only piece. You’ve gotten this far—now you only have a little bit longer to go.

Photo of stressed worker courtesy of Shutterstock .

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

take-home-test

Here are 84 public repositories matching this topic..., siddhujetty / product-analytics-insights-collection.

My Solutions to "A Collection of Data Science Take-Home Challenges" by Giulio Palombo.

• Updated Oct 17, 2019

adib / Card-Tray-Demo

A clone of Apple's Wallet app

• Updated May 25, 2017

pineapplehq / hiring-exercises

Welcome Hiring Process & Exercises - heywelcome.com

• Updated Sep 7, 2021

ChrisDrit / appointment-scheduler

Rails Appointment Scheduler

• Updated Oct 12, 2021

arecvlohe / tech-interview-projects

A list of take-home assessments for companies local and remote

• Updated Oct 25, 2022

andrestoga / take_home_robotics_coding_test

This repository contains all the take-home coding tests I've done during my job hunting in Robotics.

• Updated Mar 6, 2020

lumahealthhq / backend-interview

• Updated Aug 16, 2024

lumahealthhq / front-end-interview

• Updated Jul 8, 2023

cockroachlabs-field / sales-engineer-take-home-exercise

Quick technical exercise for those interested in Sales Engineering roles at Cockroach Labs

• Updated Sep 1, 2023

jiminny / join-the-team

Interested in joining the Jiminny Engineering team? Start here!

• Updated Mar 29, 2024

tachyonlabs / Android-Credit-Card-Input-Exercise

This was a from-scratch "take-home project" assigned to me by a company I was interviewing with for an Android Developer role. They liked my submission well enough to bring me in for onsites, so I thought I'd put it up on GitHub as another code sample, as nothing about it is specific to that company. See the README for full details.

• Updated Jul 25, 2019

brotzky / lightyear.io

Dennis Brotzky's take home challenge submission

• Updated Mar 25, 2018

adib / Cheesy-Movies

The hipster's movie app!

binghuan / MyRakutenSingapore

Coding Test from Singapore Rakuten

• Updated Sep 22, 2022

techno-disaster / Take-Home-Projects

Flutter projects companies give as a take home assignment

• Updated Feb 8, 2021

riccardogiorato / moonpay-full-stack-challenge

moonpay fullstack challenge - take home test

• Updated Jan 16, 2022

ericmikkelsen / asana--take-home-test

Take home test for asana

• Updated Jul 15, 2018

anjali-chadha / log-analyser

Analyse log file to get user statistics

• Updated Mar 14, 2018

gordonbondon / exercises

Various coding exercises for interviews, take-home assignments, online challenges, etc.

• Updated Jun 23, 2021

anjali-chadha / gdax-service

Web service providing quotes for digital currency trades using data from the GDAX orderbook.

• Updated Feb 26, 2018

Improve this page

Add a description, image, and links to the take-home-test topic page so that developers can more easily learn about it.

Curate this topic

Add this topic to your repo

To associate your repository with the take-home-test topic, visit your repo's landing page and select "manage topics."