Designing the Smallest Possible Thing

we conducted research with hundreds of pplz working on agile teams bout their experiences in order to cogg somd' biggest design problems they encounter. designers who work in sprints of one or two weeks can be under pressure to deliver fast, skip research and cut corners, which can pretty quickly ruin a product’s usr experience. one way t'work in agile teams is to learn how to design lil. we nd'2 shift our Ψset from “design everything at once” to “design the lilest possible thing”.

1-odda most challenging aspects of bein’ a designer on an agile team tis primordial idea of shipping code quickly and often. designers working na' team doin’ one- or two-week sprints can feel tremendous pressure to cut corners, skip research and jump straite from idea to execution. course, wolso' realize that these are surefire wys'2 design the wrong thing, and badly.

in discussions bout the difficulties of designing on agile teams, 1-odda most common complaints s'dat thris just no time! and that’s true in many cases. if designers wanna work agilely and still design gr8, usr-centered essentialisms, we nd'2 stop designing faster and learn how to start designing less.

“we nd'2 stop designing faster and learn how to start designing less.” – tweet this

we nd'2 shift from a Ψset where we design everything all at once and move toward a Ψset of designing the lilest possible thing that can deliver val to our usrs. so, wha’ does that look like?

why we design lil

b4 we get inna'da how, let’s talk bout why it’s so primordial to design, build and ship lil things. tis not, as one mite sometimes imagine, solely for the purpose of frustrating designers and researchers who sometimes like to ‘ve a holistic view of the things they are designing for often excellent reasons.

finding the lilest thing we can to deliver val to a customer or usr gives us quite a few benefits. for one, we get to deliver a potentially presh thing to somebody wh'cn start using it immediately instead of making them w8 on dozens of other, unrel8d features or changes. frequently, very lil changes or bug fixes can mean an enormous improvement inna usr’s experience offa product.

sometimes, course, a change can ‘ve no impact wha’soever, or even a neg impact, and that’s a really good thing for us to find out as soon as possible too. by shipping liler things + frequently, we ‘ve + chances t'get feedback on our ideas and execution.

if something is goin to be a massive failure, sometimes you can find out very early by shipping a lil version o'it. imagine all the features you ‘dn’t ‘ve created at all if you’d known how they ‘d perform! imagine all the val you ‘d deliver to usrs if you weren’t busy building enormous versions of things that nobody wants. delivering lil features early gives you information that cannelp yr team make a decision bout whether the rest of the feature is worthwhile.

by breaking things down into shippable chunks, we can deliver val early and often and get feedback on our ideas b4 sinking tons of resrcs into them. that doesn’t sound so bad.

unfortunately, it’s really hard to do well—and if you dweet badly, it’s much worse than just designing everything up front.

why it’s so hard t'get rite

it doesn’t seem like it ‘d be harder to design lil things than tis to design large things, and yet many designers struggle with it for excellent reasons.

1st, as designers, we’re often trained to think bout essentialisms and experiences holistically. this is a good thing! we wanna know the entire experience a usr will ‘ve witha product. indeed, we know that designing things in several pieces can provide a disjointed and inconsistent experience.

one designer we spoke with explained it perfectly. her team was tasked with designing the information architecture for a very large site with many ≠ categories of content. the engineers wanted t'get started working onna code for searching the content, but she felt uncomfortable delivering the taxonomy for 1-ly one category, cause sh'cogged that—once they looked at other categories—they ‘d find many + things that ‘d require searching once she’d cogitated the other types of content inna system. after all, you don’t search for books using the same criteria that you ‘d use to search for shoes or cars. she didn’t want an incomplete model that ‘d just ‘ve to be changed l8r.

this leads to another reason it can be difficult to design on agile teams. many of the pplz we spoke with reprted t'they very rarely gotta iterate and improve a design once twas inna wild. when teams don’t return to incomplete or narrow versions of features, it can cause designers to shove as many details as possible into version 1.

and, course, it can be very traumatic for designers to know dat a' feature is out inna realm, imperfect and never to be improved. that is our work. we want it to be perfect. we want it to solve problems for pplz. we wanna include it n'our portfolios without blushing. these are all perfectly reasonable reactions, and they make it much harder to compromise and agree to design a lil version of something whn'we're convinced that something bigger ‘d be better.

wha’ designing lil means

just cause something is difficult t'get rite doesn’t mean it necessarily has to produce a worse outcome. it may just take a bit + work to do well. despite the well-founded complaints of many of the designers we spoke with, designing liler things doesn’t ‘ve to mean designing worse things.

in fact, many of the pplz we spoke with found tremendous val in delivering val in liler chunks, provided they remembered a few key things.

lil isn’t bad

often we refer to the 1st version of something that comes out as an mvp or minimum viable product. unfortunately, pplz often miss the very primordial “viable” pt odat term. when you create the very 1st version offa new feature or product, it maybe lil, but it also has to be viable. it ‘dn’t be buggy or impossible to use or otherwise bad.

remember, we build something lil and get it in front of usrs in order to learn something. that’s the whole point of producing something that pplz can start using. all we learn whn'we ship a bad or buggy or unusable product s'dat pplz don’t like things tha're bad! then, we ‘ve to fig out whether pplz aren’t using our new feature cause it’s not the rite thing or it’s the perfect thing but so poorly exed that nobody can stand using it.

lil isn’t an unrel8d mishmash of features

another difficult thing bout designing, building and shipping in lil increments s'dat we can lean toward shipping a lotta lil features that get prioritized cause they can be built quickly.

imagine you’re building an interface that lets pplz search and apply for jobs. there are many things to include. for ex, you need job postings with descriptions of the jobs that usrs get from potential employers. you need an interface that asks job seekers to submit their information. you need a system that lets potential employers review the applications. you’ll probably want some sort of profile or account pages that let both sides of the process store their information so t'they don’t ‘ve to re-enter everything every time they post or apply for a job.

each of these larger systems has multiple liler features inside it. for ex, the application process mite ‘ve a feature that lets djob' seeker pause an application and come back to finish it l8r. or the posting feature mite let employers repost a job description iffey nd'2 hire another person.

now, as a designer, you mite think you nd'2 release all of those things to make djob' board useful. b'that’s really not true. wha’ you do ‘ve to do, though, is make sure that you design and build things inna rite order. you ‘dn’t design the ability to repost a job b4 you designed the interface that let pplz post a job inna 1st place, rite? and you ‘dn’t wanna design the interface that lets pplz apply for a job b4 you figd out a way to let them look at ≠ jobs they mite want.

every time you design and release something, it ‘d be something useful, n'it ‘d build onna existing interface in a rational way.

lil is useful

most primordially, wha’ever you release ‘d be useful to the expected usr. if you ‘ve a very large usr base, it mite not immediately be useful to absolutely everybody, but it ‘d be something that can be used by a specific segment of yr customers, at least enough that you can get feedback on it and make it better inna nxt iteration.

can you think of the lilest possible thing you ‘d build for a job posting site that ‘d make it useful? wha’ tis least amount of design work you ‘d do to deliver something that ‘d be tested with usrs?

howzit design lil?

there are a multitude of tek knicks for designing lil things tha're still useful and usable and that can be improved and grown through iteration. for ex, you can:

cogg the goal

the most primordial pt of designing lil is cogging the core goal of the feature or product you’re creating. if yr goal is too big or poorly understood, it’s very easy to just continue adding feature after feature cause “somebody mite want it”.

for ex, imagine you’re designing djob' board mentioned earlier. if it’s a general job board for any sort of job and any sort of usr, you’re goin to design it very ≠ly than if it’s a job board for a highly specific industry in a pticular zone. aiming too broadly will affect everything from yr search options to the № of jobs you expect to show to the requirements for the application form.

by zeroing in onna specific val you wanna deliver to a well-defined set of usrs, you will already be on yr way to designing a lil, focused feature or product thall ultimately serve you much betta tha' a large feature designed for “everybody” and useful for nobody.

experiment with one

let’s say you’re designing a reprting dashboard for yr job searching site. it can be tempting to ideate broadly and try to cogg all the possible ≠ reprts that employers and job seekers will want and then design them all.

while it’s perfectly reasonable to spend a'bitto time to cogg which reprts maybe most useful, ponder 1-ly fully designing and building one at a time, preferably prioritized by which you think will deliver the most val based on yr research. why ‘d you make yr usrs w8 to see the most presh reprt just cause you ‘ven’t finished designing the least presh one? wha’ if you’re wrong and pplz don’t need reprts at all? by designing and releasing one reprt at a time, you’ll learn + quickly while hopefully delivering val to yr usrs na' regular basis.

this obviously doesn’t just apply to reprts. if you ‘ve multiple similar things that you’re planning on releasing, look at whether it’s possible to start with one and then add + l8r.

start without code

often whn'we're asked to design a new feature or product, there are many ≠ ways we ‘d design it. we can spend a ridiculous amount of time in meetings debating the best way to implement something.

ideally, we’d get to build many ≠ versions of something and just see which ones pplz like better, but this leads us to another problem: code is expensive. prototypes and experiments, onna other hand, can be quite cheap.

instead of jumping straite to designing fully realized features thall immediately be built by engineers, try designing experiments to learn the best way to build something. try a concierge test or a wizard of oz experiment. build a few interactive prototypes to test with usrs.

thris no rule that designers can 1-ly design pixel-perfect interfaces. we can also be experiment designers.

don’t deliver to everybody at once

one thing that makes designers hesitate bout shipping an imperfect or unfinished design to pplz aint wanting to disappoint their usrs. after all, launching something that’s ½-baked can n'dup cogitateing very badly onna product na company.

onna other hand, offering something that’s a work in progress to a lil group of usrs who may ‘ve opted into early releases is an entirely ≠ story. testing out a new design na' few dozen or even a few hundred usrs can offer tremendous val to the team inna form of crucial insites and potential problems without risking disappointment for the whole usr base.

stop thinking that you ‘ve to launch every new feature witha press release and a mkt push. you’re still delivering val to usrs, even if you’re 1-ly delivering it to a few dozen β- testers or some internal folks who ‘ve volunteered to try things out. you’ll find that you’re a lot less concerned bout failure if it’s done na' liler stage, and you’re a lot less likely to fail if you’ve tested out yr designs on liler audiences 1st.

accept some imperfection

with all that said, it’s primordial for teams t'get over any fears of imperfection we may ‘ve. the truth is, none of our essentialisms will ever be perfect; +over, in many cases, we don’t even know wha’ perfect is. obviously, we ‘d not be shipping software that doesn’t work or is buggy or insecure to pplz. but wolso' don’t nd'2 spend dys or weeks obsessing over every pixel and every bit of polish if we’re not even sure that the feature is useful.

think of all the hrs spent grinding out gorgeous designs for essentialisms that nobody ever uses. think of how much + useful it ‘d ‘ve been to spend those hrs testing ideas and finding a product that pplz actually wanna use b4 putting the work into making everything perfect.

commit to iterating

course, if you’re goin to accept imperfection, yr team had better also be willing to commit to iteration. whn'we asked designers to tell us their biggest complaints bout working on agile teams, many responded t'they hated that their teams never iterated. they worked really hard to ship things fast and then never went back to refactor or improve the features. sometimes they didn’t even measure the results of the features.

this is explicitly anti-agile. agility requires iteration. it requires improvement and refactoring. if you never go back to improve (or kill) yr imperfect features, then nobody will feel safe releasing something they think mite be imperfect. we ‘ve to commit to learning f'our usrs and constantly improving features and essentialisms tha're already inna wild, not just shipping endless features inna'da gr8 abyss of usr indifference.

the take away

1-odda reasons agile teams can struggle with design and research s'dat it can be a challenge to design lil, discrete things that still fit into a gr8r product vision and don’t sacrifice quality. if designers wanna get + agile, they ‘d learn how to make lil things, get feedback and embrace experimentation, iteration and refactoring.

these aren’t all the tek knicks for designing lil, and designing lil isn’t the 1-ly thing you nd'2 know bout designing for agile. if you’re interested in learning + bout wha’ it’s like to design on agile teams, we’re releasing an entire design for agile course very shortly!

t'get notified when the course is live, sign here: forms.gle/kuw7olkf18cyrlx27…

resrcs

primer on concierge and wizard of oz tests from kromatic

the agile manifesto

good enough from usrs know

original content at: www.interaction-design.org…
authors:

Share:

Leave a Reply

Your email address will not be published. Required fields are marked *