How one weekly hour kept a custom software project moving

• Kevin Allen

The working rhythm behind an ongoing technology partnership with a New England metal fabrication company.

The client’s main stakeholder had two jobs to keep doing: estimating work and managing fabrication projects. Helping us develop software had to fit around those responsibilities.

That was one of the hardest parts of the engagement from our side. We needed the knowledge of someone who understood the business, but that person could not spend the working week in development meetings.

We settled on a standing one-hour session every Wednesday between our lead architect and the client’s key stakeholder. It became the regular place to review delivered work, give feedback and decide what should happen next.

The hour was not the client’s entire contribution. They also reviewed features between meetings and involved colleagues where needed. But a protected weekly session gave the work a reliable rhythm without requiring an open-ended meeting schedule.

First, show what was delivered

We begin with the work completed since the previous meeting.

Our lead architect walks through the requested features and what has been delivered. The client can see the functionality, assess whether it fits the way the team works and identify anything that needs to change.

This puts working software at the center of the conversation. We are not asking the client to approve an abstract description and then wait for a distant unveiling. We are looking at something concrete together.

That also makes room for useful disagreement. A feature can reflect the original request and still need refinement once the client sees it in context. The review is the place to catch that difference and decide what to do about it.

Then decide what matters next

After reviewing the completed work, we move to the next priorities.

The question is practical: what would the client like us to work on next to make the application more useful? The answer is informed by what they have just seen and by what has happened in their business during the week.

The engagement started with broad technology needs and a smaller application, not a complete specification for everything that exists now. As the client saw the possibilities of software built around its work, the scope expanded.

The weekly conversation gave that expansion a place to be discussed. It did not mean abandoning planning or treating every new idea as an unlimited commitment. It meant choosing subsequent work with the client, using feedback from the software already delivered.

Leave time to use the work before the next review

In many cases during this engagement, requests discussed on Wednesday were developed over the next two days. That gave the client Friday and the following days to review the changes before the next Wednesday meeting.

They could examine the features outside the live walkthrough and share them with other people on the team. The next conversation could then include feedback informed by that review, rather than just a first reaction on a call.

That timing describes our experience with many requests in this engagement. It is not a promise that every feature takes two days. Larger or more complex work needs its own planning.

The useful principle is to leave room between delivery and discussion. Software needs to be seen in the context of the work it is meant to support. A demonstration alone cannot tell us everything.

The client did not need to become a software designer

Collaboration took different forms depending on the problem.

For estimating, the client had a spreadsheet template that showed how the team organized its work. We used that as a starting point. For proposals, the company showed us its existing format, which helped shape what we built.

Those were concrete design inputs. The client did not have to translate every field and business rule into a technical specification before we could have a useful conversation.

In other areas, the starting point was a business need rather than a finished design. The client wanted a way to keep track of vendors and use historical quotes. We worked out how the application could support that need, then brought the result back for review.

The division of responsibility mattered. The client supplied knowledge of the work and feedback on what would help. We took responsibility for translating that into software. Neither contribution could substitute for the other.

A rhythm that fit this business

We did not ask the client to adopt a formal software-development methodology. We organized the collaboration around its available time and the decisions we needed to make together.

The recurring meeting had a purpose beyond reporting progress. It connected what the client requested, what we delivered and what the business needed next.

For this engagement, an ongoing technology partnership provided that continuity. The application could keep evolving as the team used it, instead of treating the first version as the end of the relationship.

The Wednesday slot itself was not the important part. The important part was that a knowledgeable stakeholder had a predictable opportunity to influence the work - and a development partner responsible for moving it forward between those conversations.

Make participation practical, not optional

Custom software still needs a client’s time. A development team cannot responsibly guess its way through the details of someone else’s business.

But that does not mean the client has to manage every technical task. In this case, a defined review session, working features and time to respond between meetings gave both sides a practical way to contribute.

The question for another business is not whether it can copy our calendar. It is whether it can identify a knowledgeable person, protect regular review time and agree on a first problem worth solving.

Contact us about a workflow you need to improve and the time your team can realistically contribute. We can discuss an approach that fits both.