The Lean Launch: Develop (Phase Three of Five)


Fractal (Photo credit: Wikipedia)

Now that’s we’ve discuss the define and design phases of building an application, we’re ready to get technical. The develop phase can largely run in parallel with the design phase. As always, we’ll take a top down approach and we’ll use the planning we started in the define and design phases to help organize us in the development phase.

Unlike the define and design phases, development does not necessarily need to go in order. As development also tends to be 80 to 90% of the work, if you can find a way to break development into smaller pieces and set flexible milestones, do so. You may also wish to identify the pieces that actually need to be there for launch, and save the rest for afterwards. If you have a team, I highly suggest using one of the major engineering management paradigms, such as Scrum, Kanban, or XP, as you develop towards launch. We won’t cover those methodologies, but instead we will focus on how the work in the define and design phases ties into development.

For this phase, we assume your project will fall into the Model-View-Controller paradigm, as is typical of web and mobile applications. Some projects may not fall into this category; in that case, you’ll need to adjust your expectations and find alternative ways to build your planning into your development work.

Develop, Step 1: Pick your technological stack.

There’s a few decisions you’ll need to make before you fire up your code editor. Do you need a hosting service? Domain name? Email management? What languages will you use? What libraries and systems will you need? These decisions will depend both on the needs of your project and the skill set of you and your team. You don’t have to make every decision up front, but you’ll definitely want to know how you’ll be storing information, how you’ll be routing users to that information, and what you’ll use to allow users to take actions. You’ll want these major components settled before you start digging in.

Once you have your technical stack decided, I’d recommend getting a splash page up and let people enter their email addresses so you can notify them at launch. You can also ask these same people to help with your research and testing.

Develop, Step 2: Use your attributes and relationships from the define phase to make models.

In code, models are representations of users and objects that allow various attributes to be stored about them. It’s often best to start at the model layer. Use the documentation from the define phase about attributes and relationships to get started. The documentation won’t map out 100% to your Object-Relational Mapper (or similar system), but the documentation will ensure that how the application is planned and designed stays in sync with the way the application is developed.

Develop, Step 3: Use your processes from the define phase to pseudocode controllers.

Now that you have your basic models set up, it’s a good time to use the processes from the define phase to start pseudo-coding controllers. Controllers define how an application functions. Most developers also like having the screen requirements and wireframes from the design phase before starting here. I would recommend thinking of the RESTful actions while figuring out how to organize the functionality: show, list, new/create, edit/update, and delete. This pattern can explain the majority of actions that a user can take on themselves, another user, and various objects in the system. I would mostly write the ideas down in comments first, and come back later to turn them into real working code. You’ll likely want to establishing your routing (URLs) as well before moving on to the next step.

Develop, Step 4: Use all four steps from the design phase to implement your views.

It likely makes sense at this point to migrate the design work into the code base. Views is the technical term for how the functionality is presented to the user. You’ll likely want to get the style guide into the system first, either in CSS, XCode, or whatever tooling you are using to develop your project. Then, use placeholder text and images to get the views laid out within your templating system. Don’t focus on getting every detail on the first go; as with everything else in this process, use a top-down approach. Resolve the big issues first and then drill down into specifics later on.

Develop, Step 5: Process-by-process, develop out your project.

Divide your application by processes. Try to accomplish getting one process to work at a time. You’ll need to translate pseudocode into real code, adjusting your models and views to work with the system as you go along. The order in which you develop will likely be obvious, but when in doubt, use a top-down approach again.

As you finish each process, I highly recommend setting up a variety of testing on each process so you don’t get too far ahead without regular testing. The types of testing you’ll want will likely include usability, accessibility, multivariate/split, unit, functional, quality assurance, and sometimes performance and security. If you built it yourself, have someone else test it for you as well; don’t rely on only one person for testing. Use your documents from the define and design stages to verify your work.

Conflicts will arise as you develop your application. Use your planning and user research data to resolve conflicts. Building anything is always more challenging than your original estimate; be flexible, communicative, and compassionate. Revisit and update earlier documents as needed. Conduct more research if you need to. Don’t be afraid of pushing some things out to after launch; your goal is to build just enough to start getting people to use your project. Any more than that will likely be too difficult; you can and will add more later. And as always, keep a sustainable pace.

Develop, Step 6: Launch and party!

Once you’ve developed out all the processes you need to start getting people to use your project, and you’ve testing out those processes, make a final sweep. And then, launch it!

As always, take the time to celebrate your successes, big and small. Also allow yourself time to breathe, reflect, and prepare mentally for the next phase. All of this work, and soon reality sinks in… you have to get the word out, and start establishing yourself and your organization. Next time we’ll cover what you’ll need to do to get started on the next part of your journey.


  • Let your planning and research guide your technological organization and decision-making.
  • Keep the top-down approach going. Focus on the big picture first.
  • Stay flexible, keep calm, work sustainably, and be compassionate to yourself and others. Building things is much more difficult than it initially may seem.
  • Take everything in one step at a time. Break big things into smaller things as you need to.
  • Active, ongoing testing is critical to development success.
  • Celebrate your successes, big and small.


  • Phase 1, DefineThesis, Users, Goals, Objects, Relationships, Attributes, & Processes
  • Phase 2, DesignRequirements, Wireframes, Style guide, & Composition
  • Phase 3, DevelopServer, Models, Controllers, Views, Development, & Launch
  • Phase 4, DistributeBranding, Account, Write, Business plan, Research, Legal, & Monetize
  • Phase 5, IterateResearch, Design, Develop, Market, & Support