What Happens in the First 30 Days of a Software Project

Here is what a healthy first month looks like, week by week, and what the client should do.

Week 1: Kickoff and alignment

What the team does:

  • Holds a kickoff meeting with everyone involved
  • Reviews your brief, goals and constraints
  • Interviews stakeholders and, where possible, real users
  • Agrees on how you'll communicate: tools, meeting times and response expectations
  • Sets up project tools: task board, shared documents, chat and a shared drive
  • Confirms the success measures for the project
  • Identifies risks and unknowns

What you should do:

  • Name one decision-maker on your side
  • Share everything relevant: documents, brand files, existing systems, competitor examples
  • Give access to any systems the team needs to see
  • Be clear about priorities, budget limits and hard deadlines
  • Introduce the team to the people who will use the product

Deliverable at the end of week 1: a written summary of goals, scope and the plan for the next three weeks.

Week 2: Discovery and planning

What the team does:

  • Maps the user journeys and the key flows
  • Turns requirements into a prioritized list of features
  • Separates the must-haves from the nice-to-haves
  • Produces the first version of the technical plan: architecture, technologies and integrations
  • Breaks the work into phases and sprints
  • Updates the estimate, if the picture has changed

What you should do:

  • Answer questions quickly. This is where delays begin.
  • Challenge the feature list: is each item necessary for the first release?
  • Confirm the priorities
  • Review and approve the plan

Deliverable at the end of week 2: an approved scope for the first release, a roadmap with milestones and a clear list of what is not included.

Week 3: Design and foundations

What the team does:

  • Creates wireframes of the key screens, then visual designs
  • Builds a clickable prototype, so you can try the flow before any code is written
  • Sets up the technical foundations: code repository, development and test environments, automated checks and deployment pipeline
  • Starts the basic building blocks, such as login, navigation and the data structure
  • Begins security and access setup

What you should do:

  • Review designs promptly and give specific feedback: "this button is hard to find" is better than "I don't like it"
  • Test the prototype with a few real users, if you can
  • Confirm that code repositories and accounts are in your name
  • Provide content and brand assets that were requested

Deliverable at the end of week 3: approved designs for the main screens and a working development environment.

Week 4: First working software

What the team does:

  • Builds the first thin slice of real functionality, from the screen through to the database
  • Runs the first demo of working software, even if rough
  • Tests what's been built
  • Reviews progress against the plan
  • Adjusts the plan based on what it has learned

What you should do:

  • Attend the demo and try the product yourself
  • Give feedback in writing, listing what works and what must change
  • Review the budget and schedule status
  • Confirm priorities for the next phase

Deliverable at the end of week 4: a working early version you can click through, plus an updated plan and a status report.

What good communication looks like

A short weekly meeting on progress, risks and decisions. A written weekly update summarizing what was done, what is next and what is blocked. A shared task board you can see at any time. Quick responses, within one working day for normal questions. Early warnings. Problems are raised as soon as they are known.

Signs the start is going well

You can describe the project goals in one sentence, and so can the team. Scope is written down and agreed. You know who is working on your project and what each person does. Decisions are recorded. You have seen designs and a first demo. The team asks sharp questions and pushes back when something doesn't make sense. Accounts and code are in your name

Warning signs

If you see these in the first month, raise them straight away. Early course correction is cheap.

Key points

  • Weeks pass with no visible output
  • The team avoids showing work in progress
  • Answers to simple questions are vague
  • Scope keeps changing without a record
  • You've never spoken to the people doing the work
  • Accounts and code sit under the vendor's name
  • The plan has no dates and no milestones

Your own checklist for the first 30 days

Before the kickoff:

  • One-page brief shared
  • Decision-maker named
  • Brand assets and content gathered
  • System access prepared
  • Budget and deadline confirmed

During the month:

  • Attend the kickoff and weekly meetings
  • Respond to questions within a day
  • Review designs with specific feedback
  • Set up accounts in your name
  • Attend the first demo
  • Review budget and schedule

At the end of the month:

  • Scope for the first release approved
  • Roadmap with milestones received
  • Designs approved
  • Working early version seen
  • Risks and next steps understood

Common mistakes by clients

Disappearing after kickoff, and returning only at the end. Slow feedback, which delays the whole schedule. Changing priorities weekly. Sending feedback from many people without a single owner. Waiting to share content, which holds up design and development. Not looking at demos carefully, so problems surface late

How DECHY runs the first month

Our first month follows the same rhythm on every project, adjusted to its size. In week one, we hold a kickoff and agree on goals, roles and how we will communicate. We also set up access, a shared plan and your code repository.

Weeks two and three are for discovery and design. We map the users, the flows and the risks, then turn them into screens and a technical plan you can review. By the end of the month, you see a first working demo. It is small, but it runs on real infrastructure.

You get a weekly update in plain language and a single point of contact. Decisions are written down, so nothing depends on memory. If scope changes, we show the effect on cost and timeline before it is agreed.

Most custom software projects with us cost $25,000 to $80,000. Use the cost estimator for a first range, or tell us about your project to see a sample plan for your first month.

Next step

Planning to start a project? We'll show you exactly how our first 30 days would run, and what we'd need from you to make them count. Talk to DECHY.