Handling Revisions: Fair Policies and Clear Boundaries

# Revision clause template

## Revisions
1. The Project Fee includes [2] rounds of revisions per deliverable.
2. A revision round includes changes requested within [5] business days of delivery.
3. Changes requested after [5] business days are considered new work.
4. Additional revision rounds will be billed at [$75] per hour.
5. Changes that exceed the original scope require a separate change request.

## What Constitutes a Revision
Revisions are changes to existing features within the agreed scope.
New features, pages, or functionality are not revisions.
They are scope changes subject to a change request.

## Feedback Requirements
All revision feedback must be provided in writing.
Feedback should be specific and actionable (e.g., "Move the button 20px left"
rather than "Make it look better").

const revisionPolicy = {
  includedRounds: 2,
  windowDays: 5,
  additionalRate: 75,
  scopeChanges: "Billed separately as change requests",

  calculateRound: function(roundNumber, isInWindow, isScopeChange) {
    if (isScopeChange) {
      return { billable: true, rate: this.additionalRate, type: "scope change" };
    }
    if (!isInWindow) {
      return { billable: true, rate: this.additionalRate, type: "late revision" };
    }
    if (roundNumber <= this.includedRounds) {
      return { billable: false, rate: 0, type: "included revision" };
    }
    return { billable: true, rate: this.additionalRate, type: "additional round" };
  },

  getStatus: function(roundNumber, daysSinceDelivery) {
    const revision = this.calculateRound(
      roundNumber,
      daysSinceDelivery <= this.windowDays,
      false
    );
    return `Revision ${roundNumber}: ${revision.type}`;
  }
};

console.log(revisionPolicy.getStatus(1, 3));
console.log(revisionPolicy.getStatus(3, 2));
console.log(revisionPolicy.getStatus(1, 7));

class FeedbackCollector:
    def __init__(self, deliverable_name):
        self.deliverable = deliverable_name
        self.items = []

    def add_feedback(self, section, current_state, desired_change):
        self.items.append({
            "section": section,
            "current": current_state,
            "desired": desired_change,
            "implemented": False
        })

    def get_round_summary(self):
        total = len(self.items)
        return f"Feedback round: {total} items for {self.deliverable}"

    def implement(self, index):
        if 0 <= index < len(self.items):
            self.items[index]["implemented"] = True

    def completion_percentage(self):
        if not self.items:
            return 100
        done = sum(1 for i in self.items if i["implemented"])
        return round((done / len(self.items)) * 100)

feedback = FeedbackCollector("Homepage Design")
feedback.add_feedback("Hero section", "Blue background", "Use brand green instead")
feedback.add_feedback("Button", "Rounded corners", "Square corners")
feedback.implement(0)
print(feedback.get_round_summary())
print(f"Completion: {feedback.completion_percentage()}%")

def consolidate_feedback(stakeholder_comments):
    all_items = []
    for person, comments in stakeholder_comments.items():
        for comment in comments:
            all_items.append({
                "from": person,
                "comment": comment,
                "resolved": False
            })

    consolidated = {}
    for item in all_items:
        key = item["comment"].lower().strip()
        if key not in consolidated:
            consolidated[key] = item
        else:
            print(f"Duplicate feedback from {item['from']} ignored")

    return list(consolidated.values())

feedback_data = {
    "CEO": ["Make logo bigger", "Use blue colour"],
    "Marketing": ["Make logo bigger", "Add more whitespace"],
    "Developer": ["Use blue colour", "Optimize images"]
}

result = consolidate_feedback(feedback_data)
print(f"Consolidated: {len(result)} unique items")
for item in result:
    print(f"- {item['comment']} (from {item['from']})")

# Framing revision limits positively

"We include two rounds of revisions to ensure the final product
meets your expectations without endless back-and-forth. This keeps
the project focused and delivers results faster.

If you need additional rounds after that, we can add them at a
discounted hourly rate. Most clients find two rounds sufficient."

function shouldPushBack(request) {
  const reasons = [];

  if (request.round > 2) reasons.push("Exceeds included rounds");
  if (request.daysSinceDelivery > 5) reasons.push("Outside revision window");
  if (request.isScopeChange) reasons.push("Scope change, not revision");
  if (request.specificity < 3) reasons.push("Feedback too vague");

  return {
    pushBack: reasons.length > 0,
    reasons: reasons
  };
}

const revisionRequest = { round: 3, daysSinceDelivery: 7, isScopeChange: false, specificity: 2 };
console.log(shouldPushBack(revisionRequest));