web designers Wrentham Massachusetts

Wrentham website design

web design app

Hello and welcome to this website design Web Designer Wrentham video tutorial.

I’m Owen Corso from Google.

web design quiz web design jobs entry level

And today, we’re going to build a rich media expandable creative with video.

Let’s start by selecting file, New File.

This opens a dialog box where we will set up our ad.

First, let’s make out high of project.

We have four options– The default is Display & Video 360so we will leave that as is.

web design yourself

Latest Dental Implants To Be Used

ADRIENNE PORTERFELT: You've probably tried to buy somethingonline or had to fill out some formfor your kid's school, and it's reallyhard on your phone.

It's really hard.

MUSTAFA: There seemsto be a dark art when it comes to nativeapplications, and they're such small details thatyou're actually working on.

[MUSIC PLAYING] Quite often, developers willjust throw on input fields onto a page and not reallythink about the UX that's attributed to that.

So they'll think ofa flow of a form, but they won't necessarilyfeel that individual input, so how a user struggles.

And we know thatautocomplete really helps speed up theuser experience and makes fillingforms quite nice.

What are your feelingsand experiences on autocomplete andAutofill as a thing? ADRIENNE PORTER FELT:From the user experience, you've probably triedto buy something online or had to fill out someform for your kid's school.

And it's reallyhard on your phone.

It's really hard.

It's even hard on desktop.

You don't want to get upand get your credit card out of your purse,which is downstairs.

And these browserfeatures just really improve the userexperience of using a form.

In fact, we find that peoplefill out or submit the form 30% faster if the formworks with Autofill.

So we very much suggest thatweb developers think about this.

You want people to besubmitting your forms.

Right? So if you really want yourforms to be submitted quickly, easily, work with Autofill.

MUSTAFA: And why do you thinkdevelopers don't do that? Is it very difficult to do? I'm assuming it's just a fewattributes you add to inputs.

Right? ADRIENNE PORTER FELT: Yeah.

It's actually not that hard.

So you basically need to setup autocomplete attributes, and you need to makesure that you're not doing any fancy things thatreplace the normal select and input elements withother types of elements.

I think most of these developersjust don't think about it, don't realize,that you just need to put a littlebit of extra effort in to make sure that yourform works well with Autofill and to test it out.

MUSTAFA: Is that oneof the challenges, I suppose, like people makingthese custom UI things, which are not native but justlike divs or whatever and replacing that? Is that where thingsfall down with Autofill? ADRIENNE PORTER FELT:Honestly, there's a few things that can go wrong,but that's one of the big ones.

Yeah, so someone wants thisreally beautiful custom form where the dropdown isall fancy and custom.

And as a result of that,they're using all divs.

And the browser can'tfigure out, oh, this is supposed to be a form.

And then in that case,Autofill isn't going to work.

MUSTAFA: And Isuppose there's a lot of accessibilityissues connected to that as well, it looks like.

But from your pointof view, you've got designers anddevelopers, they want to do something custom,like unique experience.

But then as someone whoworks on the browser, you want to say, now letthe browser do the work.

Do you think there'sa middle point there? How can developers at leasthave a custom experience that's unique to theirproduct, but at the same time without breaking standards? Because this is one of thebiggest challenges on the web.

ADRIENNE PORTER FELT:So there's a lot of things you can do tochange the look of the form on the page while stillusing the select and input elements that HTML provides.

Right? You can customizethem in many ways.

I have to admit, there is onething you can't customize, and it's the lookof the dropdown, like in a select element.

But everything else, the wayit statically looks on a page, you can customize.

And the browser will stillknow that they're fields.

MUSTAFA: Yeah.

What you see is thebiggest challenge then, for Autofillor implementation, from your point of view? ADRIENNE PORTER FELT:I think it's honestly that developers don't thinkabout it, that people don't think to themselves that theyreally need to be testing their forms in this way.

When you've made it yourself,you've filled it out 100 times.

You tested it yourself.

And you don't thinkabout the fact that a user is goingto be coming to it in a different state of mind.

They're tired.

They are tryingto fill it out as fast as they can on the phone.

So I think developersjust aren't really thinking about the factthat they need to take these extra small steps.

MUSTAFA: So in terms ofbrowser compatibility, the things you're using willbe Chrome-specific stuff? Or is that open source-- not open source, butit's cross-platform.

ADRIENNE PORTER FELT: Yeah,that's a good question.

So specifically autocompleteattributes for Autofill, that's standardized.

All the browsers respect them.

With that being said, thereis one part, turning Autofill off-- that's the autocompleteoff attribute-- is not respected by all browsers.

But if you say,this form should be a credit card, thatwill be respected by all the major browsers.

MUSTAFA: But eachexperience, is there slight quirks per browser? Because obviously, that's goingto be a browser-specific thing.

ADRIENNE PORTER FELT: Some are-- they have veryslightly different UIs.

For example, maybe they'llbe integrated with a keyboard widget versus a dropdown.

But I think they're prettysimilar across browsers.

MUSTAFA: You work on theactual Chrome UI itself.

ADRIENNE PORTER FELT: Yes.

MUSTAFA: So are you actuallybuilding that design and code yourself, or are youworking with UX designers in that process? ADRIENNE PORTER FELT: Sowe have a design team.

And the design team helpsus figure out what those UI elements should look like.

We actually have a bigredesign coming up this year that I think is going tomake those substantially more beautiful and also help clean upthe code, which I know that it won't affect most people becauseit won't look any different.

But from our perspective-- MUSTAFA: It's much cleaner.

ADRIENNE PORTER FELT: Man,the code's so much cleaner.

MUSTAFA: What's the actualprocess of you actually creating UI? Because for me, I do front-enddevelopment and code.

But it's like there seemsto be a dark art when it comes to native applications.

And they're such smalldetails that you're actually working on, which the user maynot notice because it works.

But if it's broken,they will see it.

What is the actualprocess that you go through with your Chromedesigners to actually making the UI or testing it? I'm asking lots ofquestions all at once.

ADRIENNE PORTERFELT: Yeah, it's OK.

It's OK.

So I'll talk about theprocess a little bit.

So usually at the beginning,Product, Eng, and the designer will get togetherand talk about what they hope for from the feature.

Often, the designwill then come up with some conceptualmocks of what they feel the feature could look like.

They'll get feedbackfrom Product.

They'll get feedback fromthe engineers, like can we actually build this, whatare the corner cases we need? And then we'lliteratively get closer to what we actually can ship.

So I work on across-platform team, which means that whatwe build has to ship on all of Chrome's platforms.

People think of Chromeas one platform.

But actually, it'sWindows and Mac-- which previouslyhad different UIs, but we're coming toone single standard-- Android, iOS.

And so we have to havedifferent mocks that relate to the specific platforms.

So some things may bepossible for some subset.

Anyway, the designers get allthis feedback from engineers, like, we can do thishere and not there.

And then we iterativelycome through to red lines, which isour final set of designs.

And that's what we implement.

MUSTAFA: So in termsof do the designers work with the actual W3C? Because you'redesigning something which has to beconsidered cross-platform at the same [? time.

?] So likewhen the payment request API, like I was working withsome of the team there, there seems to be thingswhere you have to really be seeing whateveryone else is doing so that the experiencethat you're creating is not so widely different.

And that can be quitechallenging for the designer and developer because youinstinctively want to make it, I don't know, "better.

" But you don't want to makeit so vastly different, because then you stick out.

ADRIENNE PORTER FELT: That'san interesting question.

The challenge here isthat with specs, we try not to specify whatthe UI has to look like.

We try to talk about what theuser experience should be so that we can have the appropriatecallbacks, et cetera, to build that experience.

But we don't like tostandardize the UI itself, which is a fine balance becauseyou have to have a UI in mind when you're designing the API.

But we try to make itas general as possible so that we can build differentUI experiences on top of it.

MUSTAFA: Are you workingwith the browsers as well at the sametime to do that, or is it you do things independently? Because there's the thing.

It's like if you do it[INAUDIBLE] the browsers, then you may be leddown a path that's not the best for everyone.

That it's, OK, it'slike a compromise.

But at the same time, you don'twant that complete disparity.

ADRIENNE PORTER FELT: Itdepends a lot on the standard, honestly.

Some of them willbe heavily driven by Chrome or some other browser.

They really want this API.

They'll drive it, and thenget a little bit of feedback along the way fromother vendors.

Whereas others,from the beginning, there's severaldifferent browser vendors working together.

So honestly, it differsfrom standard to standard.

MUSTAFA: And we're coming to the10-year anniversary of Chrome.

What do you thinkthe future of say, Autofill, or just workingwith the other browsers? Because it seems like thingsare getting much better.

I was speaking toDarren, and it was like, the implementationof Flexbox was a nightmare becausethe standard kept changing.

But with CSS grid, it'samazing that there's so much cross-collaborationbetween the browsers, which is great for the users and thedevelopers working across this.

What do you think the futureis for Chrome as a platform and, I suppose, Autofillas well as a specific? ADRIENNE PORTER FELT: Sofor Autofill specifically, it's hard to saybecause I don't think the limitation there reallyis the lack of browser vendors cooperating.

I feel like actually, there'sbeen a lot of discussion, for example, aroundpayment request.

There's a lot of collaborationbetween Safari and Chrome.

I think that thereal problem we have is that Autofill dependson developer adoption.

Right? If it's hard for thebrowser to figure out what form's in thepage, we're not going to be able to Autofill it.

And so I think thething we really care about is whetherwe can get developers interested in andusing the tools that we have provided for them totry to improve the Autofill experience.

MUSTAFA: Yeah.

Do you ever have toremove a feature when you see there's not wide adoption? Because I can seefrom an engineer, you're working on Chrome.

You spent your heart andsoul working on this feature.

And then you know it'sgreat for user experience.

You know from theresearch that Autofill will help transactions,and it's just nicer.

But if adoption doesn'thappen, how do you [INAUDIBLE]?? It's the biggest-- ADRIENNE PORTER FELT: Yeah,that's a really hard one.

I've been througha few deprecations.

They can be really challenging.

It's very hard.

So there are a few waysyou can look at it.

One is how many usersinteract with websites that are using such a feature.

And obviously, thatnumber is large, you don't want to create apain point for a lot of users.

But even if thenumber is very small, it might be that there are afew websites, a few companies, whose entire businessmodel depends on having access to this API.

And so that can make itvery difficult, where OK, even if it's thisreally a niche thing, it still can behard to deprecate.

So I think there have beenlots of ongoing discussions in general about howto make that trade-off.

Some of the onesI've been involved in relate specificallyto security and TLS, where if something is makingthe web as a whole as safe, we may have to breaksome connections in order to deprecate it.

And it can be areally painful thing when you've got old serverson the internet that aren't being upgraded.

And maybe it's only a smallpercentage of overall page loads, but it'sstill frustrating when a user is trying to getto a website and it's broken.

MUSTAFA: Yeah.

But ultimately, fromChrome's perspective, it's the user's experiencethat's paramount.

Right? ADRIENNE PORTER FELT: Yes.

MUSTAFA: And theirsafety and security.

So it's like HTTPS, you couldprobably explain it better, but there's a cutoff pointwhere if your site is not loaded on HTTPS, you're goingto get a message saying, this isn't secure.

That's true.

Right? ADRIENNE PORTER FELT: Fora long time in Chrome, we showed HTTP as neutral, HTTPas just plain text and no TLS.

MUSTAFA: Sorry, what's TLS,just for my non-designer-- ADRIENNE PORTER FELT: Oh, TLSis the underlying protocol that makes HTTPS HTTPS.

It's why it's secure.

So there is HTTP,which doesn't have any of the end-to-endsecurity bits on it.

And HTTP websiteswere just shown as a neutral standard thing.

Right? Most websites on the web wereHTTP, but that's changed.

We went from a few yearsago, we were at 25% HTTPS.

And now, it's the opposite wherewe're at more like 75% HTTPS.

So made changes in theUI to back that up.

So now when you go to awebsite that says HTTP, it's going to also say"not secure" next to it so people reallyunderstand what that means.

MUSTAFA: That decision mustbe quite tough, though.

In some respects, you need toforce the developers to say users' security is paramount.

But at the sametime, does it feel like you're breaking the web? ADRIENNE PORTER FELT:It doesn't really feel like we'rebreaking the web.

First of all, Ithink people have seen this a long time coming.

We've been talking aboutit for a long time.

We've rolled it out in phases.

So first, we started showing"not secure" specifically for pages with passwordsand credit card form fields.

And then it was for allform fields and web pages when viewed in incognito.

And now we're rolling itout for all HTTP websites.

And as you can see, becauseHTTPS adoption has really increased, it's onlyimpacting less than a quarter of page loads at this point.

MUSTAFA: So really,we're just talking about protecting the user.

ADRIENNE PORTERFELT: Yeah, and I think users have a right to knowthat their information isn't secure when they'regoing to this website and help them make adecision about whether or not they want to keep using thatservice or go to another one.

MUSTAFA: And do youthink users are quite savvy now to see those things? Or is this part of theeducation for the user as well to say, look,there are certain things on the web which arenot secure that you have to take into consideration.

ADRIENNE PORTERFELT: I'll be honest.

We have literally billions ofactive users, so it's hard to-- MUSTAFA: Make ageneral [INAUDIBLE] ADRIENNE PORTERFELT: --say generally whether people are goingto understand it or not.

We think enoughpeople understand it that they have a reactionand that they can reach out to sites saying, hey, Ireally like this site, but I wish it were secure.

And we see people doing thatas we've been rolling out these warnings.

SPEAKER 1: The way thatcellular networks are set up is that there's alwaysthese fringe areas, and there's alwaysthese breakdowns.

And higher latencyis always there.

Wrentham website design

Next, we can select the type of ad.

We want to make an expandable, so we select Expandable on the left.

Next, we can set again ad’s dimensions.

We are building a 320 by 50that expands to 480 by 250.

So I will make those changes.

We then assign the Wrentham creative a name.

I will leave my Save ToLocation as the default, and leave the talk about set to Quick.

Once I’m happy with my settings, I click OK.

Google Web Designer creates the initial pages of the ad for me with the dimensions I defined.

 

website design Wrentham

The collapsed page already contains a Tap Area event to expand the ad and an expanded pageWrentham with a close tap area to collapse back down.

web design xampp

💸 How to budget for your web design project 💸 - Web Design is Broken e05

web design with html & css3

As part of Intuit’s core initiatives to further cultivate mobile first thinking and accelerate growth into global markets, the Intuit Small Business Group’s Design Org has shifted from a model of designing and shipping prioritized features to a model where every designer is responsible for end-to-end, cross-device experiences, which includes designing for our products and services on desktop web, mobile web, desktop client apps, and native mobile apps.

As a design lead for our ecosystem of native mobile products over the past few years, I started getting a lot of questions around guidance and principles for mobile design. I noticed many of the designers, product managers, and engineers who are new to mobile app design or don’t live and breathe mobile app development on an everyday basis didn’t fully understand the nature of designing for native platforms and device capabilities. To reinforce the notion that “cross-device” and “mobile first” isn’t just about designing for smaller screens and scaling across multiple device sizes, I collaborated with the Design Systems Team to establish a set of mobile patterns and guidelines so that designers can hit the ground running, or run even faster, with mobile design. We recently published some guidelines, tools, and resources on our internal design toolkit that I thought would be great to share some key points and takeaways with a wider audience as the documentation addresses many frequently asked questions around mobile patterns.

Firstly, I want to start off by saying that what I write here is simply for guidance. Our mantra for any kind of pattern guidelines documentation we provide is, “Give me guidance, but let me drive.” We don’t want to be prescriptive, and we don’t want to tell you how to design, but this is a good starting point to get you going on native mobile designs. Why are we calling out native mobile? As we continue to design device-agnostic, end-to-end experiences and features for products and services, we must remember not to neglect the different platforms (i.e. our mobile products are currently offered on both iOS and Android).

Overall Principles

1. Respect the platform

We documented patterns and components based on native operating systems that we have apps on: iOS and Android. When designing for native platforms, you should consistently refer to the native OS design guidelines first for maximum quality. Keep in mind that native platform guidelines constantly evolve, so it’s always good practice to stay on top of these guidelines and refresh your memory and knowledge often.

Apple’s Human Interface Guidelines: https://developer.apple.com/ios/human-interface-guidelines/

Google’s Material Design Guidelines: https://material.io/guidelines/

2. Focus on the customer benefit

Always design for the customer benefit first. No use case is the same, and many use cases have exceptions. Do not design something simply because you can reuse a pattern or component for another feature. Design patterns help ground us as a system and unify an experience across an ecosystem of products, but they should by no means be the first or last stop in the design process. Always question yourself: How will this benefit the customer?

3. Think device first

Push your thinking beyond “mobile first.” Start thinking about leveraging device capabilities first. The native mobile device has a lot to offer: touch, voice, pressure, location tracking, accelerometer, notifications, etc. You are designing around the device, the platform, the user experience. How can these device features be utilized in our products? How can the mobile device benefit users beyond the screen interface in front of them?

4. Keep scalability in mind

Growing from the previous principle, do remember that a mobile device isn’t just a phone. Scalability across devices, more specifically between a phone and tablet, is a common challenge among designers. When we think of mobile devices, we know there are tablets, phones, phablets (not small enough to be a phone, not big enough to be a tablet). Some of the recurring questions I get asked are: Should there be parity between web and tablet designs? Can we translate the phone patterns to be the same on tablets? How do we design for phablets (not small enough to be a phone, not big enough to be a tablet)? To answer these questions, we researched with users, took an in-depth look at device interfaces and screen sizes, and set some standards. While the phone and tablet share many similarities, users use them very differently.

PHONE INTERFACE

Mobile interfaces LESS THAN 7 inches width should be treated as a phone. Syntax and layout should be aligned across these devices as much as possible, but we also want to leverage native platform guidelines and capabilities first and foremost.

A fundamental design principle for mobile phones is to include only necessary information. Do not overload the user with more than they need to know or take action on. The phone is a convenient way to consume information on the go. Small business owners use a phone to complete quick actions while they are not in the office, capture data, view content, then perhaps close it out and come back to take a look later.

TABLET INTERFACE

Mobile interfaces GREATER THAN 7 inches width should be treated as a tablet. Syntax and layout should be aligned across these devices as much as possible, and by no means should they need to align exactly the same as the less than 7-inch interfaces.

Tablet designs should look and feel like desktop web, but they should function like the phone (with tap/swipe/hold gestures, transitions, etc.). Many users view the tablet as a hybrid device. We’ve encountered many small business owners that don’t own a computer, but they own a tablet, and those users treat the tablet as a reliable device they can do work on.

To scale for the future or additional digital interfaces, you should also think about non-mobile touchscreens like TV displays, interactive table displays, automobile displays, laptop displays that you can touch, etc. You want to make sure you can scale for multiple screen sizes, large and small, and not limit yourself to thinking only about the devices your products are being supported by.

Patterns and Guidelines

This list is a small subset of patterns and guidelines that I’ve found designers have been commonly asking around best practices for our mobile products.

Screen Transitions

One of the major aspects that make navigating content on native mobile platforms so delightful is the transitions between screens. Two questions I get asked a lot are: When should a push (screen pushed in leftward from the right) be used? When should a modal (screen pushed upward from the bottom) be used? We’ve established the following best practices:

A push is essentially the fundamental screen transition to view a new screen that is stacked on top of the previous screen. There is typically a Back button so user can view the last viewed screen. For screens that are primarily for viewing, such as transaction detail screens or lists, we use a push.

A modal is typically used when we are requiring the user to select, edit content, or input data. All of our transaction forms use full screen modals as it requires more user thought due to several form fields on one screen. The titles bars for these screens typically have Cancel and Save or Cancel and Done actions. Then, when you tap Save, you get a push screen because you are viewing (not editing) the saved content.

Call to Actions

This section highlights a question I often get: “Should this call to action be a button or a text link?” In both iOS’ and Android’s design guidelines, text as buttons is the norm and recommendation. However, I feel when we use text, especially with a system font against a dark or light background, we lose out on a major opportunity to incorporate brand elements, such as our ecosystem green color or line iconography. So, we’ve deliberately moved away from using text as call to actions, and instead use buttons with high contrast, which also makes it very clear that it is a call to action and not just part of the screen content.

Empty States

Our empty state screens provides a first impression to users who are new to our products. It usually consists of an illustration, a brief description, and a clear call to action. A common and current design trend is the usage of gray text on a light background. If you decide to follow that trend, make sure the text is readable and accessible by analyzing the foreground and background colors to meet the WCAG 2.0 color contrast ratio requirements.

Carets

Firstly, yes, it’s spelled caret, not carat or carrot. 🙂 Carets are used to promote discoverability. Historically, we try to use carets for every instance we want to indicate that the user should tap into the row to view more. However, in our forms, we are working toward to moving away from using carets and instead utilize the extra real estate by creating visual cues and conversational content design to indicate tap targets to view more. After some user testing with different design treatments, we’ve found that discoverability isn’t as much of an issue as we thought. Users will naturally tap on rows, whether there’s more information provided to them or not. We only want to use carets when absolutely necessary.

Action Sheets

General rule of thumb for native mobile design: Use action sheets whenever there are multiple actions associated with a single call to action (that is not a system blocker). Apple iOS guidelines calls these action sheets. Google Android calls these bottom sheets. Use action sheets/bottom sheets whenever there are multiple actions associated with a single call to action.

Cards or Tiles

A card (or tile as other teams may call it) is a component acting as a rectangular container for a certain amount of information: visual elements, instructional text, diagrams, and action triggers. There are two types of cards based on appearance and usage: action card and info card.

Dialogs

We use native system dialogs for critical alerts, permissions related alerts, system blocker alerts, etc. The key word is “alert.” Note that for actions that aren’t related to these things, we try to use action sheets.

Fonts

The general rule for native mobile design is to use system fonts as much as possible. However, we needed to incorporate our brand and voice and tone to create what we call “QuickBooks Ownable Moments.” For large headlines and sub-headlines, we use our brand fonts. For body text, we use system fonts. For fonts within buttons, we use system fonts.

Toggles

Toggle switches are used to trigger a binary operation (i.e. turning something on and off). It is used often to replace a web checkbox metaphor. We have a lot of checkboxes in our web products so when we design for native mobile, we want to make sure we are only looking to replace binary checkboxes that allows for things like enabling or disabling content, show/hide content or fields, turn on/off tax, track returns for customers, instead of checkboxes used for selecting multiple items.

Again, these are just a few guidelines to get you started or to accelerate your mobile first design process, especially for native mobile. You are the driver and designer with creative license to define the end-to-end user experience for your products and services. Trust your gut, follow your instincts, but always remember to respect the platforms, focus on the customer benefit, think device first, and keep scalability in mind!

Yvonne So is a Principal UX Designer @Intuit currently crafting meaningful experiences for small businesses around the world. With a passion and mission for making technology more inclusive of everyone, she regularly speaks and writes about mobile UX, accessibility, innovation, and empathic design.

Building Expanding Creatives - Google Web Designer

Image by bluesbby / CC BY

Intuit has open-sourced ‘Karate’, a framework that makes the tall claim that the business of testing web-APIs can actually be — fun.

I know what you must be thinking. There’s no way that making HTTP requests and navigating the forest of data that is returned could be fun.

But really, that’s what developers who tried Karate had to say. It actually didn’t surprise us. Because Karate was born out of a strong dis-satisfaction with the current state of solutions that exist. And a lot of thought went into Karate to keep it simple and elegant, to allow the user to focus on the functionality instead of boiler-plate, and to keep things concise.

Karate strives to reduce the entry barrier to writing a test and more importantly — reduces the friction to maintain a test, because of how readable tests become.

The obligatory “Hello World” example may throw some light on the unique approach that Karate takes.

Hello World!

So if you found that compelling, and if you or your teams are in the business of testing complex web-service APIs, be it REST, SOAP, JSON, XML or GraphQL — do check out Karate.

Karate is in the early stages of adoption by teams within Intuit, but we decided to open-source this right away, so as to accelerate the process of community feedback. It is our firm belief that Karate is already equipped to take on the challenge of testing any real-world web-service, and the feature-list on the home page is a testament to this.

And your feedback can make it more awesome. It would be great to see your feature requests on the GitHub project page, and do pass on the link to those who you feel would benefit from what Karate has to offer.

And remember, testing web-services can be fun!

web design with html & css3

Sketch was made for screen-based design.
Websites, app interfaces, icons… these objects of design exist within a world of pixel measurements, RGB colors, and presentation on digital screens. Unlike many of the Adobe creative tools which include 10,000 features and the kitchen sink, Sketch is laser-focused in its purpose—and consequently works far better (and more efficiently) for what it does do.

Sketch was not made for print-based design.
Business cards, brochures, posters… these exist within a physical world of inch/centimeter/point/pica measurements, CMYK or Pantone colors, and presentation on a variety of papers and materials. Adobe Illustrator and InDesign are two of the most popular tools in this arena.

If you’re like me, you’re far more efficient working in Sketch.

And when a print design project rolls around, you might find yourself yearning to continue using the same tool you’ve become so adept at using for web/UI design. I want you to know that it’s possible. Here’s how I do it:

(full disclosure: Adobe Illustrator is required)

The Magic Number 72

Dating back to the craft of setting lead type for a printing press, the primary units of measurement were points (72 per inch) and picas (12 per inch). Lead type (pictured here) is measured in points, and is produced in pica or half-pica increments such as 12, 18, 24, 36, and 72 points. Those numbers should sound familiar to you, as they became standard digital font sizes with the Macintosh. The first Macs used screens where every inch contained 72 pixels, resulting in 12pt text that looked practically the same size onscreen as in print. The evolution of pixels per inch (PPI) is too extensive for this article (especially since the advent of retina displays), although it’s important to know a bit about the origins of this 72:1 ratio.

This article will mostly use inch measurements, as used for print design in the US. If you are familiar with a centimeter workflow, I’d love to hear from you!

Sketch measures everything in pixel units, so we need a way to convert our design to the physical world of inches. By now you may have guessed where this is going: 72 pixels in Sketch converts to 1 inch in an exported PDF.

  • An 8.5" × 11" piece of paper (US Letter) converts to a 612px × 792px artboard.
  • A typical 3.5" × 2" business card converts to a 252px × 144px artboard.
  • When adding a new artboard, Sketch 3 gives you a few “Paper Sizes” presets. Speed things up by adding your own custom artboard presets!

The pixel dimensions of a 72 PPI layout may be far smaller than you are used to when working on websites or user interfaces. Remember that the clarity of your print project is dictated by the print method you use—Sketch’s “Show Pixels” function is of no use here!

Tips for Designing Your Layout

  • For elements in your design, try to use measurements that make sense in inches. 1px = 1pt for lines and font-sizes. I’ll often use 1/8 inch (9px) or 1/16 inch (4.5px) increments for layout elements.
  • You can use Sketch’s Grid feature to make these inch-appropriate positions or measurements easier. I suggest a grid with a 9px (1/8 inch) block size and thick lines every 8 blocks (1 inch). Show/hide the grid with ⌃G on your keyboard.
  • You can turn off “Pixel Fitting” in Preferences. There’s no need to be a stickler for pixel alignment as you would be for screen-based design.

Margins & Bleeds

Professional print shops often require your artwork to have extra space on all sides, extending any parts of your design that “bleed” out to the edge (see example below). This compensates for the slight, yet inevitable, variance in where the edges are cut on your final print. My printer asks for a 1/8 inch bleed, and I often add this to my Sketch layout (9px extra on all sides). If your design has elements that bleed, I suggest you do the same—if not, you can easily add these extra margins later when saving a PDF from Illustrator. Printers will also recommend that any text is at least 1/8 inch inside the trim lines (a “safe zone” or “critical print area”), as in the business card below.

The “Trim Lines” indicate what the final card will look like. Because trimming is rarely 100% accurate, any parts of the design that extend to the very edge should continue out to a “Bleed”. Shown here, the bleed extends to 1/8 inch outside the artwork.

Preparing the File for Print

99% of print shops are strict about the specifications of your “artwork” files. The following process will help you give printers the files they want! If your layout relies heavily on images, gradients, or shadows, skip to the next section!

When you have finished your design in Sketch, export it as a PDF at 1x scale. Many programs, such as Preview or Adobe Illustrator will automatically interpret the file at 72 PPI. You can view the PDF’s dimensions in inches in Preview (Tools > Show Inspector, ⌘I), or in pixels using Finder’s Get Info window (under “More Info”). If you save your PDF through Illustrator, pixel and inch dimensions will be automatically included in the file.

There are 2 other things we need to change about Sketch’s exported PDF:

  1. Text needs to be “Converted to Outlines”.
  2. The colors need to be CMYK values instead of RGB.
  3. Any images in the design need to be embeded as CMYK images.

Converting Text to Outlines

To ensure that your design is printed exactly how you see it on your computer, it is important to convert the text objects in the PDF to actual vector shapes, or “outlines”. This makes the text look exactly the same on any program on any computer, regardless of the fonts you’ve used in the design, and regardless of whether or not those fonts are installed on the printer’s computer.

You can convert text to outlines in Sketch (more about that here), although if your design has more than a few lines of text, Sketch will slow down dramatically. If you want a guaranteed way to crash Sketch, try selecting a dozen text objects and converting them to outlines all at once! Fortunately, Adobe Illustrator excels in this department, so we’ll use that instead.

  • Open the PDF in Illustrator and navigate to Select > All (⌘A), from the menu bar.
  • Also in the menu bar, navigate to Type > Convert Text to Outlines (⌘⇧O). Easy as that!

Converting to CMYK Colors

After opening your PDF in Illustrator, navigate to File > Document Color Mode > CMYK Color. This converts the entire document to a CMYK colorspace from RGB. That’s the easy step. Now we have to change the colors in our design to actual CMYK values.

If you’re used to screen-based design and appreciate great colors, I feel obligated to tell you that CMYK may disappoint you. Due to the nature of combining those 4 colors (cyan, magenta, yellow, and black) in ink, many bright and saturated colors are difficult or impossible to recreate. Without diving into color theory or the pros/cons of various print methods, I will simply suggest that for any color that is important to your design you see a sample of that exact color value from a similar printer on a similar material. To do this I recommend choosing a close match on a Pantone swatchbook (a bit pricey, but a great investment), or ask your printer for a printed sample of a variety of colors printed on the paper you’ll use (they probably already have these, and can give you each color’s CMYK value).

Once you’ve chosen great CMYK values for all your colors, it’s time to replace the color value for each of the elements in your design. This sounds tedious—and to a certain extent it is—but I’ve discovered a few shortcuts to help you!

  • First off, you will need to select the elements whose colors you want to change. If you aren’t familiar with Illustrator, know that a layer is only selected when you click the small circle to the right of it. Simply clicking on the layer’s name will not do anything!
  • If your design has many elements with the same color (say, all green text), they can be selected all at once by first selecting one instance of the element then clicking the “Select Similar Objects” button on the right of the toolbar. If this toolbar or button isn’t available, try navigating to Select > Same in the menu bar.
  • When your elements are selected, hold down the Shift key when you click on the fill color in the toolbar (fill color to the left, stroke/border color to the right). Even elements that are pure black need to be converted to CMYK black, for which there is a little swatch below the color sliders.

Last Step!

When all of your text has been converted to outlines and all of your colors are CMYK, it’s time to save a separate PDF (I add “-print” as a suffix to the new filename). By using File > Save As, you get a trillion options for the PDF. The single option I ever use is to add a bleed margin (my printer likes 1/8 inch) on all sides of the artwork. To do this, go to the “Marks and Bleeds” section on the left and uncheck “Use Document Bleed Settings”, as shown below.

You’re all done! Trust me, next time this process will take you half as long!

Is Your Design Image-Heavy?

If your Sketch design includes bitmap images (non-vector images), they will be automatically converted from RGB to CMYK when you change the Document Color Mode. Upon importing the PDF to Illustrator, any shadows in your design will be converted to bitmap images and any gradients will become un-editable “Non-Native Art”. Because of this, if images, shadows, or gradients are important to your design, I strongly suggest you instead save the entire Sketch layout as a PNG and convert it to a CMYK file in Photoshop using the following steps.

  1. Export the Sketch artboard as a PNG at 4.166x scale, which gives you the amount of pixels you’ll need for a 300 PPI print-ready file. Printers rarely accept bitmap images less than this resolution. Make sure your artboard includes the necessary bleed margins (described above) before export.
  2. Open the PNG in Photoshop and navigate to Image > Image Size, in the menu bar. Uncheck the “Resample” checkbox and type in either the artwork’s dimensions in inches or the “Pixels/Inch” you used when exporting from Sketch (again, this is often 300 PPI). Click “OK”.
  3. In the menu bar, navigate to Image > Mode > CMYK Color. This will alert you that Photoshop is converting the file to a default CMYK color profile. This step may visibly change the colors of your design. Rest assured that your computer screen is not an accurate representation of colors in print, although you should also not expect the same bright or saturated colors capable with RGB (as described above).
  4. Adjust the colors slightly if you desire, then Save As a .psd or .tif file. Be sure to tell the printer what bleed margins you included in the artwork!

Of course you can use this process in conjunction with the PDF + Illustrator workflow above, by embedding the Photoshopped images into your Illustrator document. But most of the time I stick to one process or the other.

Is This Workflow Right for You?

If you’re fast at designing in Sketch, feel more at ease or more creative using it, or aren’t very familiar with Illustrator/InDesign, this may be good for you. This may also be a useful workflow if you have existing designs from Sketch (an interface, icon, logo) that you want to prepare for professional printing. I can’t read the future, but with Bohemian Coding’s small team and success focusing on screen-based design, I don’t advise you to hold your breath for print features. It’s a huge can of worms!

Examples of projects made with this workflow. From packaging, to letterpressed business cards, to laser-engraved signage. This work for Juice Shop recently won the Type Directors Club’s prestigious annual design competition.

I’ve written this article to share my workflow for print design projects, but also to learn of ways that I might improve this workflow in the future. If you have any suggestions, especially related to Illustrator or the print process, feel free to share them!

Be the first to know when I publish new design articles and resources.
 
I just released Sketch Master — online training courses for professionals learning Sketch. You’ll learn tons of tricks and practical workflows, by designing real-world UI/UX and app icon projects.

Sketch Master
Sketch Master is a collection of video training courses for professionals learning Sketch—the popular design tool. sketchmaster.com