Building great technology starts by building a great process. This Playbook describes the process we use at IWebSquare, and includes all of the best practices, and tips and tricks we've learned over the years. We encourage new and potential clients and new employees to read it so they know what to expect when working with us. This is a living document that is regularly updated by our team as we learn new and better ways of doing things, so expect to see changes and improvements over time.
We find most of our new clients through referrals from our current clients. Others locate us as a result of our involvement in the tech community or find us on Google. After doing a bit of basic research, they'll generally contact us by completing a form on our site or by sending us an email.
After we get the initial request, we’ll schedule a 30-minute call to talk about the project in greater detail and answer more specific queries such as:
- Does your project come under our area of expertise (
custom software, web apps, mobile applications, integrations, and website design)?
- Have you got an adequate budget for the scope of the project?
- Does your company's timeline work with our present availability?
Once we’ve confirmed that we are a good match for your project, we are going to talk a bit more about the iWebSquare culture and our philosophy on developing the technology. We'll dive into more detail regarding charges and timelines as well.
If it seems like we have a good fit, we are going to generally sign a mutually facing NDA so that you know your IP stays protected, and then we’ll begin the first (and most critical) step of the development process, the discovery phase.
The Discovery Phase
Developing custom software is naturally complicated. Even relatively simple applications have hidden layers of complexity that need to be discovered and taken into account before commencing development. The discovery phase enables our team to invest the time required to understand your app from A to Z entirely and look at every necessary feature, user story, user type, screen view, etc., which in turn allows us more accurately estimate cost and time.
Usually, the discovery process consists of:
- Explaining the various types of users (general user, admin, super admin, etc.).
- Talking about all major users stories for the different kinds of users
- Describing all main attributes of the app
- Creating wireframes for the primary pages of the app
- Determining which technologies are going to get utilized for the front-end, back-end, server, etc.
- Creating a detailed timeline for each main section of the app and every phase of the software development process
- Developing a comprehensive cost estimate for every significant part of the application and every step of the software development process.
After the discovery process, we'll give you a comprehensive document that explains all of the items mentioned above.
The Design Phase
Great apps start with great design. You can build the most amazing app in the world, but if it's ugly and difficult to navigate, no one will want to use it, and your efforts will all have been for nothing. The success of your app is as crucial to us as it is to you. Therefore, we place a high level of importance on getting the design correct, to ensure you end up with an application that’s as stunning as it is functional.
Generally, our design process includes:
Building wireframes of each page of the application: Wireframes are black and white sketches that show the layout of each page. They show the general structure of the different views and where buttons and content will go. They may also describe user interactions, like swipe left, swipe right, single tap button, double tap button, etc.
Sitemap Construction: Once all of the wireframes are complete, we usually build a sitemap showing how all of the pages and sections of the app interact with each other. For instance, it will show which page a user is taken to when they click on a button or complete a form.
Graphical Interface Design: Next, we’ll be ready to design the graphical interface of your app. At this stage we decide on font types, color pallets, icon libraries, etc. All of this will be incorporated into a style guide, which can be used to guide future design campaigns.
Color Mockup Creation: Once the style guide is complete, we build full color mockups of each page of the app, showing exactly what each fully designed page will look like.
Interactive Prototype: Finally, we import all of the mockups into InVision App, and link them together, creating an interactive prototype that looks and feels like the finished app. Explore all of our prototypes.
Coding is the most complex and time consuming part of building software, so we only start writing code once the discovery and design phases are complete. This ensures your budget isn’t wasted building features and functionality that will require major revision, or worse yet, have to be thrown away and completely rebuilt. It’s best to make these mistakes during the much less costly design phase, when things can be changed with just a few clicks of the mouse. As we mentioned above, we would not take on a project without a discovery process or design phase (skipping these steps pretty much ensures failure), we would rather decline the project than agree to a process that we know will fail.
On most projects, the development phase includes:
- Setting Up the Development Environment. We begin by setting up our development environment, which basically involves getting all of the systems and software in place to start developing.
- Developing the Data Architecture. This includes structuring the database in the proper way, setting up user authentication and user accounts, etc. At this stage we are basically laying the foundation of the app.
- Building Features. We take all of the user stories discovered during the discovery phase and enter them into Jira, our developer project management system. We then assign those stories to the different developers on the project, and estimate the time required to build each one. As the developers complete the features, they mark them off in Jira, and the feature is moved to quality assurance.
- Quality Assurance. As features are completed, our quality assurance team reviews the code and tests the feature to assure quality and look for bugs. Additionally, we set up an automated test suite that will ensure the functionality of the application. We use several testing paradigms that in conjunction, provide coverage of high level behaviors of your system as well as ensure each separate modules functionality. With a proper test suite your company will be able to achieve future development, optimizations and maintenance with ease.
- Putting it all Together. Feature by feature the app is built until finally, the beta version of the app is ready to be shipped.
As you are probably trying to figure out, developing custom software applications is an elaborate process that needs collaboration as well as input from many people. It’s entirely reasonable for a project to add in half a dozen individuals (or more) from your side as well as half dozen people (or more) from our team.
To provide you with an example, the majority of our projects consist of:
- an account manager who works on the business side of things
- a project manager who oversees the project itself
- a designer
- a frontend developer
- a backend developer
- a quality assurance tester who reviews the code and tests it for bugs
Given the number of people involved, communication, collaboration, and management can be challenging. Based on our years of experience, we’ve developed the following process that we use on each and every job. It’s designed to increase productivity and maximize your budget, while at the same time keeping you up to date on what’s going on.
Here’s what you can expect when working with us:
One communication channel. The last thing we want is everyone on your team and everyone on our team spending all their time discussing the project over email. We find email to be an ineffective method for communicating within groups. It’s slow, lacks transparency and clarity, and doesn’t integrate with our other project management systems. So instead we use Wrike, an enterprise focused, work management software.
For each of our projects we create a “Wrike Project” where everyone on your team and ours can communicate and collaborate. Wrike helps in keeping track of every detail and every task to ensure all elements are in place. Wrike is the best tool for this because it creates a timeline for each project ticket, showcases how tasks depend on each other, and includes all people that can contribute to them. This level of transparency into our team communications gives you complete visibility into what’s happening on your project, both good and bad, and makes collaboration and communication between your company and ours easier and more effective.
"Building technology is a complex undertaking that requires careful planning and extreme organization. There’s thousands of things that need to be completed in specific ways and in a specific order. Trying to achieve this level of organization using email, excel, verbal conversations, etc. is nearly impossible…. so instead we use Jira. Jira is an enterprise project management software solution built specifically for developers. For each of our projects we create a Jira board and provide access to everyone on our team. Each Jira project is broken down into “sprints” which are short term (usually two week) development goals, and each of those sprints is broken down into daily tasks (stories), which are further multiple groups:
- To Do - stories that haven’t yet been selected for development
- In Progress - stories that are currently in development
- In Review Dev - stories that have been completed by the developer and are being reviewed by our project manager in Development Environment.
- Needs Modification - Stories that need to fixed because they do not meet the end goals
- Deploy on Live - When story has been completed based on the end goal of the project
- In Review Live – Ready for review in Live Environment to make sure no issues were faced on the Live Environment.
- Done - stories that passed review and have been merged Our aim is for every story to take roughly three hours to finish, therefore on any given day, each developer will need to complete 2 - 3 stories."
Our aim is for every story to take roughly three hours to finish, therefore on any given day, each developer will need to complete 2 - 3 stories.
Our Proprietary Time Tracking Software
"It’s important for everyone on your team and ours to know how much time is being spent on the project, where that time is going. To achieve this we use Redefine Teams, a team based time tracking software solution. Each of our team members uses the Redefine Teams desktop timer throughout the day to track their time down to the second, and assign their time entries Jira stories. Then at noon each day we automatically receive (via email) a report that shows you how much time was logged the previous day, who logged it, which Jira story it was assigned to, plus the month-to-date time totals for that month. This level of automated reporting ensures that you’re never left wondering
- “Did they work on my project yesterday?”
- “How much time did they spend?”
- “What did they work on exactly and who did the work?”
- “How long is this portion of the project taking?”
- “How much time did they spend on my project last week?”
Weekly Check-ins. For our larger projects, we usually have weekly check-in meetings each Monday, where we update your team on everything we completed the previous week, and everything we plan on completing in the current week. These weekly meetings are a great way for us to update everyone on your team at the same time, and for your team to ask us questions as a group. And when possible, we’ll push up our work-in-progress to our staging servers, and show you what’s been completed and how it looks.
Internal Project Management. In order to keep your project on track, it’s important for us to keep our team of designers and developers on track. To do this, we have daily, company-wide standups each morning at 11 AM. Each team member takes their turn explaining what they completed the previous day, what they plan to complete that day, and if they have any blockers (things other people need to get done before they can complete their work). If there are blockers we put together a plan to overcome them as soon as the meeting is concluded."
Here's where we view the way your app functions in the “real world.” Even the most useful code can have bugs. Therefore it is essential that your app undergoes paces by trial users ahead of launch. Beta testers usually involve the final users of the software, who'll utilize a trial version of the app in much the same manner they intend to use the final version.
Sometimes the beta process will be broken into a private beta, where only invited users get to test the app, and a public beta, in which anyone can log on and play around with a beta version of the software. This process will undoubtedly uncover bugs, as well as missing critical features, which will need to be addressed and / or added prior to the final launch.
After months of hard work and dedication, the big day arrives and we launch your live application! Corks are popped, confetti is thrown, and backs are slapped. It wasn’t easy, but that’s the point. As John F. Kennedy said, “We choose to do these things [go to the moon], not because they are easy, but because they are hard.”
Like any complex system, software requires maintenance. When you buy a new car everything (hopefully) runs perfectly. But over time, if you don’t change the oil, the engine will eventually breakdown and stop working. The same is true for software. The day will never arrive in which your application is 100% complete. A certain level of maintenance will always be needed, including:
- Error monitoring and bug fixing: All software needs to be monitored for errors on an ongoing basis. As more and more users are added to the system, and the application is used in different ways, more bugs will be discovered and will need to be corrected.
- Dependency management: Modern web and mobile applications are often built using open source frameworks like Ruby on Rails, Ember.js, Angular.js, Bootstrap, etc. Additionally, API’s (Application Program Interfaces) will often be used to integrate data sources, payment solutions, social media accounts, etc. These dependencies will change over time...new versions will be released, bugs will be fixed, and integration methods will be changed. To keep your app running properly, you will need to update and maintain these dependencies on an ongoing basis.
- Performance optimization: As you add users to your application, performance will be impacted, so ongoing optimization will be needed.
- Security: Cyber criminals are constantly finding new ways to hack web apps, so ongoing security maintenance and monitoring is essential. We offer different security monitoring and maintenance agreements, based on your specific type of application.
Once users start using your application, you’ll swiftly recognize that a few of the characteristics which you thought will be important aren’t truly necessary. Plus some features which you never actually thought of are crucial and have to be added ASAP. For this reason, it is essential to budget for ongoing development upfront. Remember, the best applications will always be a work in progress, and can never get truly finished.
Lean methodology and Building Minimum Viable Products
We are huge believers in lean development methodology, which is an approach to developing software that focuses on constructing the simplest version of your app (called an MVP or Minimum Viable Product). The MVP consists of just the core, vital features of your proposed application (and nothing else). This method is the quickest and most economical way to get your app within reach of users, so you can start receiving feedback and learning from their behavior Before you begin including features.
Sounds good right? We know that our customers wish to be as cost-conscious as possible while getting the perfect product in the marketplace. That’s the reason we work closely with our customers to make sure that the MVP vision is consistent throughout the team. Our experience shows that the leaner your initial offering, the more value for your money you’ll get in the long term.
Do you understand why? Because you won’t be incorporating additional functionality which, although it might appear to be a superb idea initially, isn’t actually what your users need. Why put money into code that will eventually get scrapped. Our clients have realized that it’s better to start lean and invest money only on the super-awesome features that their users have proven they desire.