We’ve been working on providing user feedback the last few weeks. It’s important to take a step back at some point, and analyze what’s obvious, and what’s… not. It can be tough to look at something you’ve created with fresh eyes. But it’s imperative to try and look at your application from the perspective of a new user.

We’ve been repeatedly signing ourselves up for new accounts, inviting ourselves, and imagining use case scenarios.

It’s such a competitive landscape these days, -there are thousands of websites vying for peoples’ attention. It’s important that your application makes an effort not to lose people at the outset.

When it comes to pre-project consultation, it’s always tough to draw the line. Most of us have a strict policy against design mockups, but what is fair to do pre-project?

For most of us, that line gets drawn based on what is easiest within the time we have available. Most of us remember a time when we won a job young in our career based upon our hopeless overworking of the proposal. Because we were so desperate for the work, and had little else to do, -we turned in the most thorough, and complete response of anyone in the group.

For most people with successful businesses, that day is long gone. There is simply no time to convey your ideas to a potential client as accurately as you would like. It’s called speculative work, -and that is a no-no.

So what defines speculative work? In its simplest sense, speculative work is anything that seems to give away too much information about your process, or takes too much time that could be used for more valuable purposes.

But what really is too much information?

How do you treat your mechanic, or your cable repairman? Because you have no idea what it is they are doing, you demand very specific explanations, and estimates of their process. The more detailed they can be, the more at ease you are about the process.

So since they told you exactly what was wrong with your car, -are you more inclined to take it to a different mechanic? No, in fact, you’re even more inclined to leave your car with them. You trust them based upon their openness.

So we can basically say that as an industry, it is good to be as forthcoming as possible. It’s important for us to develop standards where clients can trust us, and compare our services to others.

Jumpchart splits that divide; it provides a simple, quick, non-subjective way to illustrate what you will provide.

Clients simply just understand what you show them. Better yet, it doesn’t take long to get your ideas into a logical format.

Call it speculative work if you will, but it’s quick, it’s easy, and it simply wins jobs based on its comprehensiveness.

We have been using the he** out of Jumpchart for client projects. It’s been amazing looking back on past practices vs. how we do things now.

This week we had two ecommerce projects land in our lap. Both of them had unique peculiarities that were specific to an industry, and of course both of them were under-funded. In short, we had to get creative, and precise about deliverables, or we had to turn them down.

Luckily Jumpchart is mature enough to use in client work. We were able to use the quick “lorem ipsum” shortcuts to mock in content. We used the shorthand form elements to show off the way we expected the checkout system to work. We allowed ourselves to redefine the project by dragging and dropping pages between sections…

While talking on the phone, one of our potential clients changed the way the application needed to behave. It wasn’t time to panic, -Jumpchart assigned no penalty for making changes. We were able to quickly reflect the changes that needed to take place without slowing our creativity.

We’ll admit, -old habits die hard. We started the process on paper. In this case, however, the paper brain-storming didn’t last past one page. It was simply quicker to get a functional clickable prototype than it was to waste time with non-interactive paper mockups.

Better yet, the first round draft was directly presentable, and understandable by the client…

We’ve been building web based apps for quite some time now. With proper promotion, or effort, some of them might have been niche contenders. As it stands, they’re just earning mold on a backup server. A single client flight of fancy that never found its mainstream.

We’re going to be working on dusting them off to see if any of them are useful. It’s been too long in the dark for us one-off developers. It’s time the code library represented itself.

So let’s all dig through the backup server. Lets evaluate our past work. It might not be perfect, it may have been done in a hurry, -but it worked. Chances are it could work again…

You don’t have to charge a fortune for it. A dollar today is a dollar you didn’t have yesterday.

We’re many moons into the Jumpchart development, and somehow things are still not perfect… It’s amazing that the better things get, the higher our standards get for excellence. It’s so tempting to pull a Howard Hughes, and drag it on for years.

The truth is, you might expect us to behave this way if you added up surrounding circumstances. We’ve been working in an environment where we work as hard as we can given the limits of a usually too-tight budget. There is never a chance to really romanticize a project to the level that is gratifying.

So of course, given this opportunity to be our own client, we’re taking the liberty to be picky. To redo. To rethink, To grind things down to the essential.

If you saw the original screen mockups, you might not be able to imagine the path we took to get where we are today.

37 Signals talks extensively about the Cost of change. One of the goals of Jumpchart was to not impede change. Several things happen during a normal web development process.

• Content needs to be found or created, and tagged to appropriate pages in a site
• Sections need to have names
• Sub-sections need to be added to contain additional info

Inevitably:

• Content is found or created late in the process
• Content needs to be moved, or deleted
• Top-level nav needs changed, added to, or deleted
• Sections become sub-sections, and vice-versa

In all cases Jumpchart forces no penalty for the inevitable revisions. Moving, reorganizing, and changing content is a quick-click process.

What is Jumpchart?
Jumpchart is an online tool that helps you to collaboratively organize the content that goes into a website. You and your collaborators can easily add pages, sub-pages, and attach files and images as you go. Jumpchart empowers you to change your mind about where content ought to exist in a hierarchical structure.

The best thing about Jumpchart is that it has momentum into the build phase of web development. If you believe in standards based web design, and are a css devotee, you’ll never enjoy building websites more than when they pop out of Jumpchart. An exported Jumpchart is valid CSS, and XHTML that is ready to be customized, and turned into any site you can imagine.

Why do I need it?

Other tools are useful. We love Omni Graffle, and paper mocks. We really love HTML mocks. Nothing is as easy, as scalable as a Jumpchart though. A Jumpchart allows collaboration anywhere anytime. Instead of being transcribed, or reformatted, a Jumpchart is the beginnings of your website.

You may have tried any number of solutions to your IA planning and organization before. Nothing will empower you to collaborate, change your mind, and get started building like a Jumpchart will.

No more:

• Digging through email to find attachments, snippets of text, or changes
• Having clients who don’t understand your mockups
• Being unsure what you’re going to build as a project matures
• Transcribing, or reformatting text from other formats to make them useable

Like an old fashioned card sort choosing what is important should be a matter of dragging and dropping. We built Jumpchart with the idea that we should be able to prioritize, and communicate prioritization easily.

In fact, changing categories to sub-categories is as easy as a click and a drag. Changing a headline to a bullet-point, or an h2 to an h3 is a few quick edits away.

In a perfect world, changing course would be penalty free. Everyone loves to change their mind. As we learn, as we grow, we tend to rethink decisions from the past. We’re never more educated on how we should have started a project than when we have completed it…

We’ve tried our level-best to make editing and changing a Jumpchart penalty free…

It’s the toughest thing for web designers to do. Enforce a process on their clients. Clients tend to want to give us content in whatever format they find it in. But what if things were different? Imagine:

• Having your content tagged to its appropriate pages
• Finding relevant page level changes have taken place as the client reviewed the document
• Having a track record of changes via an RSS feed

You might say: “but my clients will never use a system like this.” That may be true of some clients, but have you asked them based on your experience? Have you told them that based on your experience, other, looser forms of organization tend to cause delayed timelines, and compounded errors? If you explain this, and they still choose antiquated methods then so be it. At least you can use Jumpchart to organize content, revise based on changes, and show mockups to clients rapidly.

The real situation is that most clients are understanding, and willing to pick up things you recommend. They feel pride in learning new technology, and saving their company money. They enjoy being part of a technical process that has a focus, and is collaborative.

Before you know it, your clients will be using Jumpchart to add files. You will receive changes that are made to the actual content instead of abstracted Word documents. You’ll get comments attached to the page they are about, instead of random emails that have inadequate context.

It will change the way you work… and your clients will appreciate you for it.

You can read a lot online about different forms of content mockups. There are:

• Paper mockups
• Feehand/Illustrator Mockups
• A variety of diagram planners

And of course, the new cool thing: HTML mockups.

HTML mockups are great. In fact, they’re at the core of what makes Jumpchart a good idea. They have momentum into the build phase, and clients understand what you’re trying to tell them better. html Mocks have some issues though:

• You have to throw together a workable CSS template for your mock.
• If a client changes their mind about navigation, you have to manually update a lot of pages.
• When the client wants to move content, or delete sections, you again have to make manual changes.
• You still have to find spots for all of the deliverables.
• and the biggest one… html mocks are not collaborative…

Of course some of these things eventually work themselves out. Maybe you make some include files that help you handle the inevitable navigation changes. Some of the other issues as well can be handled with some creative work-arounds, and maybe some patience.

We would never say that Jumpchart is the only way to plan projects. There are virtually infinite ways to organize, and plan your projects. We would however say that Jumpchart is simply the easiest, most rapid, and effective way to get your ideas into a logical communicative web based format that has momentum into the build phase.