Communication in distributed teams: Messenger & Rules

May 22, 2017July 17, 2017 ~ maratkiniabulatov ~ 1 Comment

In order for the distrubited teams to work, you got to have a clear flow, a set of general rules, that will fence the process and allow people to collaborate effectively around the globe. If everything is set up correctly, you are able to create amazing products with global professionals, and cover customer support 20+ hours a day.

Communication

What do you miss most when working outside of the office? ~~Procrastination!~~

Communication that is effortless in office envoronment may be not as natural in distributed teams.

Messenger (SkuVault uses Telegram, chosen for it’s ~~simplicity, availability across all platforms, stability~~ gorgeous GIF bot) and videochat software are there to try to equally substitute verbal communication.

Due to project specifics, we have the following channels in telegram:

Urgent chat, where On Call & Quality Assurance teams collaborate in order to resolve outstanding issues as fast as possible (you can read more about On Duty teams in my previous post on year retrospective);
Dev chat, that is general for all devs, covering the questions of “Who the hell broke QA again?”, …, to “So have you seen Azure copied Amazon pricing plan”.
Russian Dev chat, due to significant part of the team being russian-speaking, is for fast communication and clarification across russian devs;
Quality Assurance chat, for questions and discussions across QA members;
Freshdesk feed, for fetching freshly issues support tickets, so that if immediate attention needed -> relevant people are informed;
separate project chats with various messaging activity, depending on how big and urgent the project is.

Telegram is extremely handy when it comes to making life easier. We use:

hashtags, to mark needed messages in order to find them later. That could be #shipstation hashtag to mark everything related to ShipStation integration across all chats;
mentions, which allow to ping a person even if the chat is muted. So if dev doesn’t want to get tons of messages on a related subject, he still is notified when he’s mentioned;
great gif support (not only kittehs, but also when you need gif with reproduced bug);
bots! we fetch freshdesk support tickets, notified about engine and web errors thanks to telegram bot api 🙂
size, platform availability, stickers, e.t.c.

now this sounds like a telegram evangelism

Video Conference

When it comes to video conferencing, we use hangouts, since skype app is awful.

General Flow and Jira Ticket Descriptions

It’s bad when you lack information on stuff you need to implement. In order to minize that, we have rules on filling out the ticket, so that as less questions as possible are raised.

Ticket description has testing plan, implementation plan, sequence of steps on how the feature should work, client and needed sandbox credentials, and tons of other information. Now that doesn’t prevent requirements change, scope creeps, blind spots (we all know that software development is an endless pain and all related people should suffer), but it surely reduces questions to clarify / misunderstanding / delays to the bare minimum and greatly helps in communication.

General Flow for the ticket before it hits implementation requires it’s acceptance by PM and dev, so those are members who control whether ticket is clear enough or not.

Workplace Attendance

Although you are not obliged to come to the office, it’s still essential to be at your workplace during working hours. If you’re working flexible hours, you need to agree upon them with a manager or people you collaborate with, so that you have a consensus solution on comfortable time to work for all.

Calendar lists days off, while chatrooms are good to inform colleagues about hours off, if necessary.

Working remote takes self-dicipline and responsibility, but pays off really great.

Notifications for pinging stuck projects

Be sure you use various notifications, such as jira web hooks + telegram, email notifications on stuck code review or testing, color coding on project management boards for due dates and approaching deadlines. Alltogether, those measures prevent unexpected situations and make the risk of missing deadlines, reduces the risk of tickets stuck halfway, keeps you alarmed in almost all cases where the flow takes wrong direction.

Project Management & Business Analysis Meetup – Ufa

October 20, 2016February 10, 2017 ~ maratkiniabulatov ~ Leave a comment

So it happened – I managed to gather 2 people for PM & BA meetup (without any PR xD).

After visiting Vienna, I desperately wanted a platform to share knowledge or / and mock each other on PM & BA failures. So I created one: Ufa Project Management & Business Analysis Group

Initial meeting consisted of Me, Nur (from modulbank.ru – online bank for small businesses) and Oleg (from smena.io – various crms / solutions for partners). Both work as analysts at cool and interesting teams.

So thank you, @Nur and @Oleg 🙂 First meeting went nicely, at my favourite coffe place Chat House. Meetup went as expected: we’ve shared experience and discussed who works via which workflow, how we formalize requirements and what are the places we store them.

I miss good ole Ufa42 Conference, I think we gotta revive it 🙂

Year Retrospective @ SkuVault

June 17, 2016July 17, 2017 ~ maratkiniabulatov ~ 1 Comment

Last year guys from SkuVault offered me an amazing opportunity to help the company manage a growing development team, create organized schedule, establish workflow that reflects the company goals .

For those who don’t know – SkuVault is a Warehouse Management System (WMS). Like a swiss army knife, SkuVault manages and syncs your inventory across e-Commerce platforms, POS, Logistics and Warehouses, providing accurate quantities in order to prevent out of stocks. Headquartered in Louisville, KY – SkuVault helps to manage the inventory for hundreds of clients all across the globe.

It’s time to list some of the achievements we accomplished during this year.

Observational Research and Optimization Scenarios

For the first 2 weeks, I was examining the flow within the project, and getting to know the team. Each couple of days I published blog posts on my findings with ideas on how to improve and optimize the workflow. Some things in my new team were completely different from my previous experience:

No teamleads. That meant that developers split up into Code Review teams, and reviewed each other.
Technology stack (.NET at SkuVault vs Scala / Riak / react.js at Storia). With all the pros and cons, .NET development teams don’t have that clear BE / FE differentiation: backend developers can work on frontend tasks via ASP.NET MVC, so our devs are more like (..universal soldiers).
No UX / UI design step in the workflow. This particular part makes every decision much faster. The product itself (SkuVault Warehouse Management App) uses Bootstrap, and is very utilitarian from design perspective. Key factor here is ease of use (as much as it can relate to industrial application).
Distributed team on both sides of the Atlantic, covering almost 24 hour period.
SkuVault is used by hundreds of customers around the world, bugfixing happens daily, and there are different bug priorities. This particular moment doesn’t work well with typical “sprint->release” cycles (because the priorities may change quite fast, or something needs to be urgently released).

With all those differences in mind, I started to streamline the workflow in JIRA.

Statuses, Transitions, Workflow

I managed to decrease the number of statuses.

Used to be: 23 (with any transitions allowed between any statuses)

Became: 9 (with clear status sequence that reflects state of a bug / new feature).

Most statuses were redundant, I’ve changed some of them with combination of “labels + status”, some were eliminated and substituted by generalized statuses (for example statuses “Design Holds”, “Client Clarification” changed to status: Hold + label “IncompleteDescription”).

The Workflow is constantly being refactored and improved per developers’ suggestions and whole team feedback. Last week I’ve released the 7th version of the workflow in a year.

Flow in general, and for every team member (BA / PM / Dev / QA) is described in our wiki, as well as terminology, list of labels to apply (there is a special glossary for labels). I explain the workflow as a sequence of steps, so that there is an instruction in case of emergency, or a new person onboarding.

On Duty Teams

During the first week we started to ask developers to fill a small questionnaire to find out how often they are distracted from new feature development by urgent client requests or bugfixes requiring immediate attention. It turned out that significant time (up to 80%) had been taken by Urgent Tasks, which distracted devs and made their work less efficient.

So the management team (well, actually it’s more like PMs, CEO, CTO and Support Lead) decided to establish teams of on call devs. These teams (2 devs: Frontend and Backend) would work only on urgent tickets, which allowed the rest of the team to work on regular tasks, ideally, without distraction.

On duty team concept has been rethought a couple of times, and currently we’re aiming at having 3 devs on call each shift, as client base grew significantly, and so have the requests, tasks and points of attention. Some of developers still get pulled to urgent tasks, because SkuVault heavily relies on integrations with other SaaS / eCommerce / Shipping systems, that change their APIs, improve their products, and may occasionally alter the way they interact with our system. And on duty devs may have questions for the developer who built the integration originally.

However, the concept itself proved to be extremely helpful, and overall the issue is resolved.

Mentorship

It’s a common thing to establish, when you have senior and junior devs 🙂 In order to clarify overall system architecture questions, seniors mentor other developers and code review.

Ticket Description Standards

Creating a clear guidance on filling out the fields and required info on a bug / new feature / or any other issue type is essential to streamline development.

Changing Kanban approach to Hybrid Scrumban

In a nutshell, a year ago development boards (one for planning, one for development) included lots of statuses, was extremely heavy (as you gotta display ~1k tickets), and hard to manage. Kudos to Tim Jannace and the team , who managed to bravely (and successfully) operate and maintain this board!

However, an agile board should focus on one goal: to show a piece of flow relevant for particular scenario / area. So those two boards were split up, so that each board reflects a single scenario:

Development Board, where the tickets transition from ToDo to Ready to Release: Scrum Board;
Urgent Board, which is used by on duty teams, and includes only Critical and Blocker tickets: Kanban Board;
Quality Control Board, where developers and test managers can to see the scope of tickets they need to review: Kanban Board;
Release Board, for the release manager to overview and manage the tickets that should be merged to master: Kanban Board.

There are boards for DevOps tasks, of course, as well as for other projects, but developers mostly have to check 2 boards maximum. And both of the boards are easy to use and lightweight.

On the other hand, pure sprint -> release cycles do not reflect how SkuVault operates, because of the Urgent bits that need to be released almost daily. So sprints are more like folders here, which allow us to forecast approximate or particular start / release dates for the tickets, and limit feature scope in a given time period. That’s why it’s called ScrumBan 🙂

Notifications, Due Dates, etc

I’ve also established automated email notifications on Pull Requests or Tasks are not Reviewed / Tested for more than 2 days.

We started to use labels trigger notifications for tickets that will soon miss due date, or for ones that shouldn’t be rescheduled.

There are a lot of other specifics, changes, undergoing improvements – over the year team grew significantly, as well as number of clients – and we adjust the company flows accordingly. Developers look motivated, and I couldn’t be happier to work in such an environment.

Key findings this year:

Don’t make a release the goal itself. Quality product is the goal. So you can skip a release or two, but deliver something good. Even if there are lots of clients,they would understand the importance of stability, not the feature they want firsthand;
Write up retrospectives on problematic moments, so that you solidify foundation of your experience for yourself and others. Try to gather additional data and opinions inside the team, in order to provide a broader angle to the problem;
Make everything possible to have a good human relationship with developers and other team members. You are colleagues, and a good person will always try to do her best, if she’s motivated (see motivation reference article);
Horizontal hierarchy and a little bit of dev anarchy is always good. Every team member should have his voice at least heard;
Always update team feedback on how things are, this is essential to keep the flow up to date and address concerns that devs may have. Cause you know, in IT, team is what defines success, and good manager’s work is to facilitate work and motivate the people;
Maintain comfortable release pace for the team and the clients;
Read professional literature, but don’t forget to check how this works in reality 🙂
There is always room for optimization. You just don’t have enough time! You can spend days micromanaging things, to extrapolate optimization on global flow later. Neverending exciting job.
Maintain work/ life balance. Don’t let team overwork.

Aside of your professionalism, key things to stay motivated are team spirit and ability to apply and improve your skills. For the past year we became mature, overcame challenges, and continue to create awesome WMS for our clients. Looking forward for the next adventurous year at SkuVault 🙂

Thanks to Ksenia, Slav and Kim for the review, and SkuVault team for the support.

Tuning up Scrum Approach

June 17, 2016July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

IMG_2016-06-17 13:21:33

Recently my colleague, Tim, decided to try out Planning Poker, to have better estimations. Planning is essential, and scrum already offers a framework of how to deal with planning. But over the course of my work and experience with scrum techniques, team usually shapes

Previous experience showed that daily scrum meetings are merely pointless. Direct communication / skype / IM is much more efficient. Especially in distributes teams.

And following each and every ritual from scrum routine is time and efficiency consuming during the first iterations, since agile methodologies need a good deal of instructions. Usually, after some time teams shape up scrum as they want, and it just works, so from my experience it’s not essential to follow scrum by the book (Agile Estimating and Planning book by Mike Cohn, written 10 years ago). Here are additional thoughts on why our transatlantic distributed team doesn’t fully fit into planning classic scrum and it’s rituals:

Due to out product having two versions, we sometimes have developers jumping in and out of projects;
Since we’re distributed and flexible – it’s hard to incorporate planning poker with all it’s “team that takes the hint” practice. Distributed team of two-three people can handle classic scrum, but not bigger one.
In order for classic scrum to work, team must be onsite (together in one place), and everyone should be in one timezone. That’s not our key point, we’re strong in our flexibility, adapting to challenges and different projects. Scrum meetings are not that effective, when one part of the team has finished work day, and the second one only starts with the fresh brains

Story Points vs Ideal Days and time estimates

Story Points are valuable when it comes to relative complexity (e.g. that task is twice more complex as this one), and when the team has sort of fog of war before them. However, when elaborating on stats from burndown chart and calculating Focus Factor, we go to the point of calculating how many points / ideal days of uninterrupted development do we need. All because we need to know how to squeeze features into sprint timebox.
If you work with JIRA
1. Story Points are not as comfortable to work with, as Original Estimate field. Subtask story points do not sum up in parent ticket, unlike original estimates.
2. Story Points lack ‘remaining story points’ bit, which is uncomfortable once user story has spilled over to the next sprint. Original Estimate, in this case, can be complimented with Remaining Estimate field.
It’s not convenient to estimate buffers for unplanned work with Story Points.
At the end of the day, Story Points are calculated to that very same hours developers spends effectively inside a timebox. Do we need an additional layer of calculations, if it will eventually come to measuring time?

Planning Poker

Planning poker is a ritual before the sprint, where the team (devs, qa) estimates upcoming user stories by a consensus-estimate (average estimate of all team members), assigns user stories to developers, and discusses possible roadblocks collectively.

Don’t have anything against that, but it often comes out time consuming (not that critical as it sounds, actually), and shows lack of detail from other estimators. Moreover, planning poker usually means that devs themselves think about which ticket is to take, which is quite hard to do when we have such a vast scope (~1300 tickets in backlog) + ~2 sprints planned ahead.

But let’s omit devs and tickets self-assignment and time consumption. That’s all tunable.

There are online tools for planning poker:

https://www.planningpoker.com

http://nearsoft.com/resources/tools/planning-poker/

Estimations and Forecasting

Man Day != Calendar Day, because developer gets distracted during man day. So none of these terms reflect what we need.

Story Point is too abstract. Let’s use Ideal Day term, meaning 6 hours of undistracted work.

Key questions to answer when making a good plan (cynical comment: plan is worthless, planning is essential, as Napoleon said) are the following:

How many ideal days on average are in sprint.
How many ideal days can certain developer actually works per sprint.

Once again, Ideal days != calendar days.

Buffers and Planned Days

While starting to estimate and plan back in August, I started by making buffer of 0.5 day, thus making development occupy other 4.5 days in the sprint.

Currently it’s 1.5 days buffer, and 3.5 days of development. This may not be enough, as I’m continuing to tune and gather stats on that. I think that somewhere closer to 3 days is tolerable.

MONTH	TIME BUFFER / SPRINT	PLANNED DAYS
August	0.5	4.5
September	1	4
October	1	4
November	1.5	3.5
December	1.5-2	3-3.5

I’m aiming at 3 days of development for devs, and 2 days for code review / scope creeps / finishing up tickets that are reopened;
Time buffer includes time for Code Review, fixing Reopened Tickets, other distractions;
Planned Days = Ticket Estimated in Ideal Days multiplied by Complexity Multiplicator.

Such empiric way is basically the same focus factor scrum is offering, but without a layer of story points that you later need to convert. And btw, it falls into same ratio I had during previous two projects, which is 2/3 development, 1/3 buffer for fixes and everything else. Seems like more or less ratio across projects then.

Complexity Multiplicator

Plus we have complexity factor, which helps to form buffers. Complexity multiplicator is a combination complexity and unknown unknown. 3 ticket complexity levels:

easy <x1.2>
moderate <x1.5>
complex <x2>

The common equation for one person will look like:

Sprint = SUM(User Story x Complexity Factor) + Time Buffer

5 days = SUM(User Story 1 x Complexity Factor; User Story 2 x Complexity Factor) + 1.5

Individual numbers differ among developers.

All in all, these are estimation basics. Questions asked will add up to this post. Meanwhile, some literature to read:

resized_high-expectations-asian-father-meme-generator-you-are-scrum-master-why-not-scrum-phd-f56adf

I’m not telling pages behind those links are true / correct, but they are certainly allow to overview issues from different angles.

Manage process, not people

April 12, 2016July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

It’s all about the process

I might be a captain obvious here, but supporting a process for an analyst / pm is a more important, than micromanaging tasks amongst developer pool.

When a new team member steps in, who’s responsibility is to manage development processes, she needs to find how to make business processes inside a company better.

Business processes are evaluated from various points of view, but in a nutshell, aside from developer professionalism, she needs to make sure there’s no room for slowdowns and uncertanties when product passes different stages across different teams. Whether there are delays in communication, or delays of resources for the project, or sick-days, – there should be a correct process to tackle such cases, in order to minimize negative outcome.

There’s always a temptation to micromanage issues, no matter how big the project is and how little time you have. But project manager’s job is to create a process that allows to handle various situations. Once the process has been established – keep an eye on the workflow, so that it doesn’t jump over the fence of how the process should work.

Fencing is the key idea. Micromanagement is bad, if you don’t have a clear process: it’s time consuming, it’s inefficient on a project scale (of course there are exceptions), and most important – micromanagement doesn’t cope with scaling.

So the typical steps to establish a working mechanism is to:

Create the process
Adjust it to keep all needed operations inside that process fence
Make sure operations can connect to each other via unified inputs and outputs
Optimize the process to allow painless scaling
Do not pay too much attention to micromanagement 🙂

Team Spirit + Exciting Project = Good Product (and vice versa)

June 16, 2015July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

lego-teamwork

Product is crafted by people. It is not a sum of collaborative work. It’s usually a combination of work, excitement, collaborative ideas, feedback loop inside the team throughout the whole project lifecycle.

Passion is right at the heart of every person, and if environment tends to motivate – a person will work hard to achieve a good result (appreciated by the team and himself). Moreover, working with passionate team amplifies the overall product, makes it bigger than sum of efforts.

I approach to motivation as to a three-factor equation.

Excitement about the project (and willingness to work on it)
Ability to apply your skills (and improve them)
Compensational part

Let’s leave out compensational part. Let’s also make a note, that such approach doesn’t work on lousy boring projects.

The rest two points are extremely transparent, if you work in a smaller companies with more or less ‘flat’ hierarchy and informal communication.

Excitement about the project comes from inspiration. It could be something cool, that brings value to the market. Aspirational team, that challenges you, while you challenge them. This makes it extremely easy to go & do your job day by day. Such teams later stick together, even working on different products, to exchange ideas and share experience (as we did with Ufa42 Conference).

MhWNOxz

Once the project is exciting, challenging – person starts to work hard in order to bring his valuable contribution. Developer, manager, designer, analyst – everyone is involved into general decisions, everyone is able to improve the product from the inside. Which means he can apply his skills in a good way, practice fresh approaches and technics, learn on mistakes, tune the workflow.

However, lack of involvement in product creation (aside from simply doing your job), vertical hierarchy and formal chain of command – it all kills the motivation. This brings us back to our equation: team is unhappy, not motivated = product not exciting. World doesn’t need boring products. Don’t forget: awesome pros won’t stick with something dull for a long time, they will leave as soon as they can. And we all know, that finding great teams is something almost impossible 🙂

Storia.me App Rollout: Better Feedback Loop, Faster Iterations

May 29, 2015July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

When developing Storia.me iPhone app, we had the following circles to deliver to:

Developers
QA
Early adopters
General Audience (AppStore)

And the following problems to solve:

Provide Beta access with faster update pace and immediate critical bug fixing for early adopters (as in microsoft’s inner circle);
Make AppStore version as stable as possible;
Receive feedback on earlier stages, experiment with a limited set of users and influencers.

A scheme we came up with eventually, has three (four in special cases) versions before the final AppStore release. Each version is rolled out out for certain circle, with different readiness level.
scheme

Storia Alpha

Internal build for developers. After code is frozen, feature-complete version is sent to Preprod. Alpha version may be used as a proof-of-concept prototype, since it usually doesn’t require QA stage. Distributed via hockeyapp. Connected to dev server.

Storia Preprod

Internal build for QA team, before we release stable version. After critical and major bugs fixed, Preprod becomes a Beta. Distributed via hockeyapp. Connected to preproduction server.

Quite often preprod version is tested together with design team, in order to see how well the mockup works in extreme cases.

Storia Beta

Stable version for early adopters. Helps in revealing bugs, inconsistencies and everything else that fell out of scope during previous stages, shows overall initial reception. Has a 1-week period for testing, before AppStore submission.

Version that is used by stakeholders, everyone in the company and users from countries, where Storia is not released yet. Distributed via hockeyapp. Connected to production server.

Why hockeyapp?

It is cross-platform, meaning that we can extrapolate iOS scheme to Android.
It shows new updates instantly, meaning we can be sure that most Beta users are using the latest version.

Bug fixing and merging

Fixes are merged into current version branch. If QA team finds a bug in Beta version – fixed are merged in Beta.

It is obvious, that we cannot hotfix an AppStore version =) Critical fixes are tested in Beta and issued as an AppStore update (depending on severity). Minor fixes are added to the next planned version.

Special cases, Storia Testflight

testflight_case

Testflight version is identical to Beta and the one submitted to AppStore. Connected to production server. We use it when we need to test a certain feature on production server privately. We needed to test video recording & processing on backend, but couldn’t rollout this features to Beta access (they could have produced a lot of broken content). Testflight Version was internally tested on production server by dev and QA teams, and proceeded to App Store once all obstacles were moved out of the way.

Q: Why to AppStore, and not to beta?
A: We rolled out video recording and playback features simultaneously for general public and Beta access).

Bug fixing for Testflight version sometimes involved rolling out the fix in Beta, since hockeyapp update takes a bit less time to process.

For the past 9 months, come hell or high water, this flow proved itself to be efficient and transparent. It took two sprints initially to get used to the scheme and tune it a bit. Release cycle is stable, updates work well, adopters get new features faster, team receives feedback earlier.

I would love to hear criticism, or get a fresh look at similar distribution process in your teams =)

Many thanks to Rishat, Ksenia for edits.

Improving App Design Review, Ensuring Design is Ready for Development

May 27, 2015July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

Well-coordinated work across teams – let’s say design and development – is a huge deal when it comes to delivering a good product on time! So, part of my job as a project manager is making sure that the assets passed from design into development are ready for implementation.

At the very heart of the process, design review is nothing complex. You should know human interface guidelines, platform restrictions, requirements and a little bit of common sense =)

Here are the common issues I often face, when reviewing design:

Design does not incorporate all the details on features planned;
Navigation controls are used inappropriately from the native experience point of view; or simply not intuitive;
Assets are missing during delivery phase;
Mockup does not look good, when populated with real user data; mockup has not been stress-tested on extreme cases.

As our teams worked together, we optimized our process to minimize adverse effects on the points above.

1. Kick-off with an interview.

When the team is excited – it shines in willingness to collaborate on building a valuable product. Once an applicant to a designer position is excited – she starts to ask questions and share her ideas. I try to understand what the candidate thinks about the project, her motivation, her past projects experience: was there an established flow when this designer had been working on a product, how did the teams collaborate.

Usually, our projects involve UX and UI designer. An iPhone UX expert knows navigation controls, their proper use, typical user flows, analytics and split testing, how to structure information elegantly and effectively. She creates prototypes and mockups for the upcoming app. UI designer provides GUI for a mock up (colors, iconsets, sizes for different resolutions).

2. Help designer to understand the product, build solid requirements

There is a timeframe for a designer to get to know the product. Have materials prepared, older designs structured (for the retrospective view), corner cases described.

The whole team was pleasantly surprised when our new UX designer asked for requirements documents and stayed knee-deep in them for a couple of days. He came up with rational and neat optimization.

We describe global functional requirements in Confluence, with obstacles, corner cases and retrospectives added to the main article. This gives a designer (and practically any new person in the team) the understanding which issues and mistakes we faced, what are the bottlenecks of particular solutions, and why we currently have an effective solution if we already do.

We describe platform-specific flows and requirements in User Stories, which also work as checklists for designers.

The one thing I want to point at again, are the corner cases. They usually fall out of scope and do not apply to typical user behavior, but may result in unpleasant experience. We brief a designer on corner cases before he starts prototyping.

3. Create checklists for mockups

There is a quite popular problem companies face: real user data doesn’t play nicely with the mockup. The design may look gorgeous and trendy and flat, but once you start populating it with longer names, venues, low quality photos, vivid photos that make overlayed text unreadable – the whole greatness falls apart. What to do here?

Reflect min and max length for the fields in the requirements. This way designer knows what to expect from the real data.
Prepare corner case text examples, to check how well the mockup stands against them. For example, use location named ‘Venkata Narasimha Raju vari Bahadur’ instead of ‘Union Station’. Show how long text should be cut, if needed.
Keep in mind that if you support multiple languages, some buttons may require more space for a label to fit.
Check for active / inactive states for buttons, segments, toolbars.
Alerts and message boxes for whatever reason can be (connection loss, lack of space, unsaved data, …)
Text overlays. If text overlays a picture, be sure that text is still readable even on a bright vivid photograph.

4. Wording for mockups

Wording mistakes happen quite often. You may have ‘Done’ button in current application, and ‘Save’ in an updated mockup, or even different labels for the same action in different sections. I make sure wording is correct and synced across designs, before dev team starts implementing it. Easiest path is to have all metaphors documented inside a task-tracking or wiki-system, so that designer knows how to name each element properly. This saves a lot of time and nerve for everyone involved.

5. Standardize assets delivery

In order to be sure we got all the assets we need we created a small guide on design delivery in a form of simple folder structure.

#project_folder
    - #project_iOS 
        - #comments_screen
            - comments.psd
            - #_icons
                - icon.png (for 1x)
                - icon_@2x.png (for retina)
                - icon_@3x.png (for retina HD)
                -

This hierarchy serves to ensure we have needed states and sizes for icons, and a structure that will confuse noone.

Overall, I hope that this brief article helps you optimise your process and get design delivered faster =)

Special thanks to Ksenia, Rishat, Igor for reviews =)

How to accurately estimate external projects. Part 1 – Delays caused by communication

September 1, 2013July 17, 2017 ~ maratkiniabulatov ~ Leave a comment

This is a first article from “How to accurately estimate incoming projects” series, aimed to help you see the possible future pitfalls. This includes both outsourcing projects and the ones where different teams around the world are involved.IT industry is dynamic. Companies change APIs, IDEs, upgrade hosting servers software, raise new compatibility issues. Of course improvements are welcome, but there is no way you will have a perfect product once and forever – it needs to be re-iterated. Don’t forget about hundreds of different environments that the system should work on. And people.

1. Client Interaction Time

It’s not a big deal when we are talking about local business (and even in such close distance email response delay time could be significant and expensive), but when you’re dealing with international clients and partners, this becomes a more significant issue.

There are several simple rules that are wise to follow in order to keep up with the deadlines:

Don’t underestimate time needed for interaction;
Client won’t run and read your email instantly, he has work to do;
Response time could vary, but prepare for the worst.

Let’s look at an example: you are building an ecommerce website. The catalogues structure is a bit tricky so you need to clarify where a product recommendation slider leads.

You send the request;
Client reads it in 2 hours;
Gets back to you with some questions in order provide proper answer;
When you answer him – you are already off from work;
You read the final response the next day only.

Of course it’s not what may happen every time, but you need to take such issues into account before they happen. Here is what could cause “lags” on the client side as well:

Clarification from a third party (could be a hosting provider, lawyers, content providers, etc);
Interaction between departments;
Approval of department manager and other bureaucratic procedures.

In addition to that, there’s been quite a few times, when our clients from other countries needed to clarify detailed info with a a third-party with no people on that side speaking English at all.
The main point of this section is to make you understand how heavily client interaction lag can affect the entire project. It’s worth mentioning because these things rather frequently fall out of scope of attention.

How to avoid possible adverse effects? A checklist or a roadmap will be helpful to manage handling tasks in advance. In Codebranch, we prepare a project roadmap with Freeze dates, which are the last dates that a certain part of team-client interaction is due. For instance, there are:

Design Freeze Date – this is when the client takes a final approval and signoff to the proposed design, all the amendments and improvements to the design have to go before that date.
Functionality Freeze Date – the milestone by which the final application functionality should be agreed upon.
Content Delivery Date – this is when the content provided by client is due, so the client would know the timing in advance and have enough time to gather the content.
Hosting or CDN accounts purchase dates, domain name registration deadline – when, and no later, the accounts need to be available to the development team in order to set the environment up and deploy on time.

These dates are elaborated together with the client, basing on the delivery timelines that the client suggests, and adjusted accoring to the internal development milestones. This approach helps both the team and the client meet the responsibilities in working on a web project, and contributes into building a good working relationship.