The first 30 days of a software project: what good looks like

Delivery · 5 min read

The first 30 days of a software project: what good looks like

AK
Aamreen Khan
Managing Member · October 2026

You’ve signed. Now what? The first month sets the tone for everything after — and it’s also when you can still tell, cheaply, whether you hired well. Here’s what the first 30 days look like when a project is run properly, week by week, so you know what to expect and what to demand.

Week 1: Names, access, and a working rhythm

Kickoff is logistics done seriously: one named owner on each side, a shared channel where questions live (not scattered emails), access granted to the systems and data the work needs, and the release calendar on paper — dates you can hold everyone to. Boring, and it prevents half of all project drama.

Weeks 1–3: Discovery in the rooms where work happens

Workshops with the people who do the job, artifacts collected, the requirement document and wireframes taking shape and coming back to you for correction. Your effort peaks here — a prepared client makes these weeks sing. Expect drafts you can mark up, not silence.

Week 4: The signed blueprint and the first real slice

By the end of the month: a requirement both sides read and signed, wireframes of every screen, a ranked feature list, the confirmed price and phase plan — and development starting on the first slice, with the first working release scheduled just weeks out. From here, the rhythm is set: build, review, adjust, repeat.

The early-warning signs, while leaving is cheap

Thirty days in, worry if: nobody has interviewed the people who’ll use the system; questions get answered with reassurance instead of documents; there’s no date on which you’ll touch working software; or scope conversations feel slippery already. These rarely improve at month six. The inverse — named owners, written artifacts, a visible calendar, honest “here’s what we don’t know yet” — is what hiring well looks like up close.

The 30-day scorecard: an owner on each side, discovery done with the real users, a requirement you read and signed, and a date — weeks away, not months — when you touch working software.

What we ask of you in return

The first month is a partnership audition for both sides: we need your people in the workshops, your honest corrections on the drafts, and an hour of attention when a release lands. Give a good vendor that, and the next eleven months are mostly the calm repetition of month one — which is exactly the point.

Ready for a month one like this?

Start with the call that starts the calendar.

Book a free consultation

Legacy software: when to modernize, and when to leave it alone

Custom Software · 5 min read

Legacy software: when to modernize, and when to leave it alone

SS
Shubham Semwal
Full Stack Developer · October 2026

Every established business has one: the old system. Written years ago, understood by one person, powering something important. Vendors love to say it “needs modernizing” — usually right before quoting a rewrite. The truth is more useful: some legacy systems genuinely need replacing, some need a careful renovation, and some are best left exactly where they are. Here’s how to tell which one you own.

Leave it alone when it’s quietly winning

Old is not the same as broken. If the system is stable, does its one job well, changes rarely, and the platform still receives security updates — the boring move is the right one. “It’s not modern” is an aesthetic complaint, not a business case. Spend the money where a problem actually lives.

Modernize around it when the core is sound

The most underrated option is the middle one: keep the reliable core and build modern pieces around it. A web portal in front of an old database. An integration that frees its data for other systems. A new module for the workflow that changed, while untouched workflows stay untouched. This is renovation instead of demolition — a fraction of a rewrite’s cost and risk, and often it buys the old system another productive decade.

Replace it when the ground is shifting

The genuine replacement signals: the platform no longer gets security patches; the one person who understands it is retiring; every business change takes months because nobody dares touch the code; or the system actively blocks what the business needs next. When those stack up, a rewrite stops being vanity and becomes maintenance — and it should be done the way any build should: discovery first, data migrated like a release, and the old system retired module by module, not in one heroic weekend.

Three honest questions: Is it still safe to run? Can anyone maintain it? Does it block what the business needs next? Three good answers — leave it. One bad one — renovate around it. All three bad — replace, carefully.

Beware the rewrite reflex

Developers (yes, us included) are drawn to clean slates; businesses are better served by working software. When we assess a legacy system, the deliverable is a recommendation with the trade-offs and prices attached — including, regularly, “keep it, and here’s the small thing to fix.” A vendor whose every assessment ends in a rewrite isn’t assessing; they’re selling.

Got an old system and a decision?

We’ll assess it honestly — even if the answer is “keep it.”

Book a free consultation