---
title: "Paperless Picking: A Practical Warehouse Guide | SKU.io"
url: "https://www.sku.io/paperless-picking/"
description: "Paperless picking for small and mid-size warehouses: the hardware, scan-to-confirm vs tap-to-confirm, skip reasons, pick paths, batches and a rollout checklist."
published: 2026-11-12
---

[Inventory Management](https://www.sku.io/category/inventory-management/)

# Paperless Picking: The Practical Guide for Small and Mid-Size Warehouses

By [Kalvin Mizzi](https://www.sku.io/our-story/) · November 12, 2026

Paperless picking means a picker works from a screen instead of a printed list. A handheld tells them which bin to walk to, they scan the bin and the item, and the scan itself is the record that the right thing came off the shelf. Done well, it removes three costs at once: printing lists, mis-picks nobody catches until the customer does, and the end-of-shift job of typing ticks back into the system.

Done badly, it is slower than paper. A pick screen that needs two actions per line, hides half the product name and throws the on-screen keyboard over the card every time it moves on will be abandoned within a week, and the team will go back to clipboards.

This guide is for a warehouse that ships somewhere between a few dozen and a few thousand orders a day and is deciding whether, and how, to drop paper. It covers the hardware, the one setting that decides how fast a pick feels (how a pick gets confirmed), exceptions, pick paths, how batches get built, a rollout checklist and an honest way to estimate the return.

## What paperless picking actually changes

On paper, a pick list is a promise. The list says bin B-12 holds three of a size M top in navy, the picker writes a tick, and nobody knows whether the tick is true until packing, or until a return arrives.

On a handheld, the same step becomes a check. The picker scans the bin label, so the system knows they are standing at B-12. They scan the item, so the system knows it is the M in navy and not the S beside it. When the count is reached, the line is done and the stock movement is already recorded against the right bin.

That gives you three things paper cannot:

-   **Errors caught at the shelf.** A wrong scan is rejected while the picker is still at the bin, where fixing it costs one more scan. Caught at the customer, the same error costs a return, a reshipment and some goodwill.
-   **Live progress.** A supervisor can see that a list is 9 of 31 lines in without walking the floor.
-   **Exceptions with a reason.** “Not in bin” and “damaged” become data you can act on (a cycle count, a supplier claim) instead of a scribble in the margin.

It does not change the physical work. Someone still walks the aisles. What changes is how much of their time goes to reading, writing and second-guessing.

## The hardware: what you need, and what you can skip

There are three common setups, and most small warehouses end up with the first or a mix.

**A rugged Android handheld with a built-in scanner.** Zebra, Honeywell, Datalogic and a dozen cheaper brands make them. The scanner sits in the top edge and fires with a side trigger, so the picker’s thumb stays free. For all-day picking this is the default, because a phone camera is slow in poor light and against shrink-wrap.

**A phone with its camera, or a phone with a Bluetooth ring or sled scanner.** Fine for a few hundred picks a day, for a second shift that picks occasionally, or for testing before you buy hardware. A ring scanner turns a phone into something close to a handheld for much less money.

**A tablet on a cart.** Useful for batch picking into totes, where the screen does not need to be in the hand.

Whatever you choose, check three things before buying ten of them:

1.  **How it sends scans to a web app.** Most handhelds send a scan as typed keystrokes, the same as a USB keyboard. That is the most compatible mode, and it is also the source of the most common complaint in paperless picking: the on-screen keyboard popping up and covering the screen. We wrote up [why the soft keyboard appears on Android scanners and how good pick apps avoid it](https://www.sku.io/android-scanner-soft-keyboard/).
2.  **The suffix it sends after each scan.** Usually Enter, sometimes Tab, sometimes nothing. Your pick app needs to handle whichever one the device is set to.
3.  **Battery for a full shift, plus spares.** A device that dies at 2 PM puts someone back on paper.

Labels matter as much as devices. Every bin needs a scannable label, and every product needs a barcode the scanner can read. If half your stock arrives without barcodes, that is a receiving project to do before go-live, not after.

## Confirming a pick: scan, tap, or both

This is the decision that most affects how a pick screen feels, and it is the one most often left at a default nobody chose.

There are roughly three models:

-   **Scan, then tap to confirm.** The scan identifies the item, then the picker taps *Picked* or types a quantity. It is forgiving, but every line costs two actions, and a picker who is in a hurry learns to tap without scanning.
-   **Scan once, confirm the line.** The first matching scan confirms the whole quantity. Fast, and right for lines that are almost always one unit, or for cases picked as sealed cartons.
-   **Scan every unit (tally scanning).** Each scan adds one. When the count reaches the line quantity, the line confirms itself and the screen moves on. A three-unit line takes three scans and no taps. Oracle’s NetSuite WMS calls this tally scanning, and its documentation describes being “automatically forwarded” once everything is tally-scanned.

Tally scanning is the strictest, because it catches the case scan-once cannot: the picker grabbed two when the line said three. Scan-once is the fastest per line. Tap-to-confirm is the one to avoid as a default, because the tap is exactly the step people skip. We compare the three in detail, with when to use each, in [scan every unit or scan once?](https://www.sku.io/scan-every-unit-or-scan-once/)

Two settings usually sit alongside this choice:

-   **Require bin scan.** Forces the picker to prove they are at the right shelf. Leave it on if bins are close together or look alike; turn it off if every SKU lives in exactly one obvious place.
-   **Require item scan.** Hides the manual *Picked* button, so the only way to confirm a line is to scan it. This is the setting that stops “autopicking”, where a picker taps through a list without scanning anything.

In sku.io, picks confirm by tally scan by default: each scan adds one, and reaching the quantity submits the line with a tone and a vibration. A tenant setting switches to one scan per line, and two more toggles require a bin scan and an item scan. With the item scan required, the manual confirm button is hidden.

## Wrong scans and over-scans

What happens on a bad scan matters as much as what happens on a good one.

A wrong item should be rejected immediately, at the shelf, with something the picker notices without looking: a different tone, a double vibration, a red card. The message should say what was expected (“expected the size M in navy”), so the picker can find it without opening anything. The count should not change.

An over-scan, a fourth scan on a three-unit line, should be rejected the same way. So should a duplicate: some scanners send the same code twice in quick succession, and a pick app that counts both will overpick.

sku.io’s pick screen rejects wrong scans and over-scans at scan time with an error tone, a double vibration and a red card that names the expected item, and ignores the same code arriving twice within 250 milliseconds.

## Exceptions: skips, shorts and reasons

Something will be missing. The bin will be empty, the item damaged, or there will be two where the system says three. A paperless process needs a fast way to say so that does not stop the pick.

The pattern that works is one tap to skip and one tap to say why, from a short list of reasons:

-   **Not in bin**: the stock should be there and isn’t. Usually a cycle count.
-   **Damaged**: there is stock, but it can’t ship.
-   **Not enough**: a short pick. Pick what is there, record the rest as short.
-   **Wrong item in bin**: a put-away mistake, which is worth knowing about.
-   **Other**: the only reason that should need typing.

Most systems in this space have some version of it. Mintsoft’s app has *Skip Product*, which moves the order to a PICKINGSKIPPED status and lets the picker flag the location as missing, damaged or other. ShipHero’s mobile picking has *Report Issue* with preset reasons. NetSuite’s WMS offers *Other Bin* and *Bin Empty*.

There is a second kind of skip worth supporting: “come back to this one.” The picker can’t reach the top shelf without the ladder, so they want to pick it last rather than record an exception.

Reasons are only useful if somebody reads them. Make sure they show up in the pick list summary and the export, so a supervisor can turn “Not in bin” three times on the same bin into a count before it becomes an oversell.

In sku.io, *Skip* opens a bottom sheet of reason chips: Not in bin, Damaged, Not enough (which opens a short-pick quantity), Wrong item in bin and Other, which is the only one that opens a text field. *Skip for now* moves the line to the end of the walk and leaves it open. Reasons are stored on the line and shown in the summary, the export and the printed pick list.

## Pick paths: the walk is where the time goes

Most of a picker’s day is walking. Scanning saves seconds per line; a sensible walk saves minutes per list.

The universal baseline is to sequence picks by bin, so the picker moves through the warehouse in one direction instead of zig-zagging. Veeqo’s digital picking, for example, presents products “in ascending bin location order”. That only works if your bin codes follow your physical layout: aisle, then bay, then shelf, numbered in the order someone walks them. If they don’t, renumbering is usually worth more than any software change.

Beyond the sequence:

-   **Show one line at a time.** Linnworks’ directional pickwave setting presents “a single step to complete”. On a 4–6 inch screen, one line per screen with the bin code large is easier to read at arm’s length than a list.
-   **Show what’s next.** A small “Next: B-12” under the current line lets the picker start walking while the current line submits.
-   **Keep pick faces topped up.** A path is only as good as the stock in the pick bins. If pickers are regularly sent to reserve, look at replenishment before you look at software. Our post on [bin locations without the spreadsheet](https://www.sku.io/bin-locations-without-the-spreadsheet/) covers how pick faces and reserve stock get set up in sku.io.

sku.io already sequences every pick list by the bin walk and allocates each line to a pickable bin.

## Building batches: where pick lists come from

A pick list is only as useful as the orders on it. How you group orders, by batch (many orders, overlapping SKUs) or by wave (a time window, such as everything that must leave by 2 PM), is a separate decision we covered in [batch picking vs wave picking](https://www.sku.io/batch-picking-vs-wave-picking-which-is-right-for-your-store/). The practical question for paperless picking is where the list gets built, and by whom.

In most systems, a supervisor builds batches at a desk and pushes them to devices. That is fine when there is a supervisor at a desk. In a small warehouse the supervisor is usually also a picker, and walking back to a computer to start the next batch is exactly the kind of trip paperless picking was supposed to remove.

The workable pattern is a saved view: a filter you set up once (“open orders, this warehouse, ship by today, not on a list yet”) and reuse every time. The picker opens the view on the handheld, takes every order in it, and creates the pick list there.

Two details make this work in practice:

-   **“Take everything in this view,” not “tick 40 boxes.”** On a small screen, a select-all that only covers the visible page is not enough. You want the whole filtered set.
-   **Orders already on an open list are left out**, so two pickers starting from the same view don’t pick the same order twice.

In sku.io, the Fulfillment Orders list on a handheld has *Select all*, an “All N in this view” scope and a *Pick list* action, so a picker can turn a whole saved view into a pick list without a computer. The *New pick list* dialog also offers *From a saved view*, listing your views with a live count of open orders. A selection that spans several warehouses becomes one list per warehouse, and orders already on an open list are skipped. One request can hold up to 500 orders.

## What the pick screen should show

A handheld screen is small, and every pixel above the pick card is a pixel the picker has to scroll past. What earns a place:

-   **The bin, large.** It is the first thing the picker needs and the thing they read from furthest away.
-   **The identifier the team actually picks by.** For most catalogues that’s the SKU. Where your SKUs are long barcodes, it is the product name. And for some brands it is neither: the team reads the manufacturer part number off the shelf label. We go into this in [picking by MPN, SKU or barcode](https://www.sku.io/picking-by-mpn-sku-or-barcode/).
-   **The full product name, wrapped.** Size and colour usually live at the end of the name, which is exactly the part a one-line truncated name cuts off.
-   **An image.** Not essential, but a quick visual check catches the “right style, wrong colour” pick. When there is no image, show a placeholder, not an empty gap that looks like a loading error.
-   **Quantity, and progress through it.** “2 of 3” once scanning starts.
-   **Big targets.** Field-usability guidance commonly puts touch targets at 48dp or more, and larger for gloved hands.

What doesn’t earn a place on every line: the list number, a status chip, the warehouse name, a large header. Put those behind a menu.

sku.io’s pick screen uses a one-row header (“3 / 12” and a progress bar), shows the full product name wrapping across as many lines as it needs, shows images reliably with a fallback to the parent product’s image and a “No image” placeholder, and lets each brand choose to show its MPN as the headline.

## A rollout checklist

Go-live is where most paperless projects stall. This is the order we’d do it in.

**Two weeks before**

1.  Label every pick bin with a scannable code, numbered in walking order.
2.  Find products with no barcode (or a barcode that doesn’t match the system) and fix them at receiving, not on the floor.
3.  Pick one device model and buy one spare for every three in use.
4.  Configure the scanner suffix (Enter is the safest) and test that a scan lands in the pick app without the on-screen keyboard appearing.

**One week before**

5.  Choose the confirmation mode deliberately: tally scan for multi-unit lines, scan-once if almost every line is one unit.
6.  Decide whether bin and item scans are required. Start strict; it is easier to relax a rule than to introduce one.
7.  Build the saved views pickers will start from, one per warehouse or per wave.
8.  Run a full list on the floor with your fastest picker and your newest one. Time both, and note every hesitation.

**Go-live**

9.  Run paper and paperless side by side for one day, on different lists, not the same ones.
10.  Keep printed lists available for the first week. Removing the fallback on day one turns a hardware hiccup into a shipping delay.
11.  Read the exception reasons at the end of each day. They are your first cycle-count list.

**After two weeks**

12.  Compare mis-picks caught at packing against your paper baseline, and ask the team what still slows them down.

## Estimating the return honestly

Vendors will quote you big percentages. Your own numbers are more useful, and you can gather them in a week before you change anything.

Count, for a typical week on paper:

-   **Mis-picks** that reached packing or the customer, and what each cost you (reship, return postage, a refund, staff time).
-   **Time per line**, from a stopwatch on a few lists, including writing the tick and the end-of-shift data entry.
-   **Paper and printing**, which is usually the smallest number but the easiest to see.

Then run one week paperless and count the same things. The mis-pick line is usually where the return is, because one wrong item shipped usually costs more than the margin on the order it was part of: outbound postage twice, return postage, the refund or replacement, and the staff time to handle all of it.

Be honest about the other side too. Devices cost money, and the first week will be slower while people learn. If your warehouse is one person who picks from one room they know by heart, paper may genuinely be fine.

## Where sku.io fits

sku.io pick lists are built from fulfillment orders, allocated to pickable bins and sequenced by the bin walk. The guided pick screen takes a bin scan and an item scan by SKU or barcode, with skip and short-pick for exceptions. It runs in the browser on the handheld, so there is no separate app to install. Order routing and fulfillment are covered on our [order management](https://www.sku.io/order-management/) page.

On top of that, it covers everything described in this guide: building pick lists on the handheld from a saved view, tally-scan confirmation with tones and vibration, scanning without the on-screen keyboard, skip reasons, a picker-first layout, per-brand MPN display and images that always load.

If you’re running pick lists on paper today and want to see what this looks like on your own catalogue, [book a time](https://www.sku.io/book/) and we’ll build a pick list from one of your saved views together.

## Related reading

-   [Why the soft keyboard pops up on Android barcode scanners](https://www.sku.io/android-scanner-soft-keyboard/)
-   [Scan every unit or scan once? Choosing a pick confirmation mode](https://www.sku.io/scan-every-unit-or-scan-once/)
-   [Picking by MPN, SKU or barcode in multi-brand catalogues](https://www.sku.io/picking-by-mpn-sku-or-barcode/)
-   [Paperless picking software compared](https://www.sku.io/paperless-picking-software-compared/)

![Kalvin Mizzi, founder of SKU.io](https://www.sku.io/_astro/the-story-of-sku.BNjQHdxV_Z4P6NF.webp)

Written by

[Kalvin Mizzi](https://www.sku.io/our-story/) Founder, SKU.io

Kalvin has run his own multi-channel e-commerce business since 2008 and built the system behind it, which became SKU.io. He still gives every demo personally.

-   [LinkedIn](https://www.linkedin.com/in/kalvinmizzi/)
-   [X](https://x.com/kalvinmizzi)

## Keep reading

-   [Holding Back Stock for Your Retail Accounts When Every Channel Sells From One Pool](https://www.sku.io/hold-stock-for-retail-accounts/)Nov 21, 2026
-   [A B2B Ordering Portal Your Retailers Will Actually Use](https://www.sku.io/b2b-ordering-portal/)Nov 20, 2026
-   [Backorders Across Online and Wholesale: Who Gets the Next Delivery](https://www.sku.io/backorders-online-and-wholesale/)Nov 20, 2026
