Blog
    7 min read

    Our Agile Approach: How We Actually Work

    Our Agile Approach: How We Actually Work

    Kraftwire Software approaches Agile not as a rigid set of ceremonies, but as a lean framework designed to ship production-ready custom web applications in six weeks. We eliminate the "Agile theatre" of excessive meetings and complex story-pointing in favor of weekly rhythms, outcome-based user stories, and continuous deployment. By focusing on individuals and interactions over processes and tools, we ensure that startups and businesses in the UK, USA, Brazil, Japan, and Europe receive high-quality software without the overhead of traditional agency models.

    Agile Without the Theatre

    Somewhere along the way, "Agile" became synonymous with meetings. Daily stand-ups that last 45 minutes. Sprint planning sessions that consume an entire Monday. Backlog grooming, retrospectives, and demo days that leave developers with only small windows of "deep work" time.

    This isn't Agile. It's theatre.

    The original Agile Manifesto is famously brief · just 68 words long. It does not mention Jira, story points, or two-week sprints. Its primary value is: "Individuals and interactions over processes and tools."

    At Kraftwire, we take this literally. Our process is designed to stay out of the way so our engineers can focus on building products like Ginza or converting web apps to mobile via KW Native. Here is how we actually work to maintain a six-week MVP delivery timeline.

    Weekly Rhythms, Not Sprint Ceremonies

    We don't use traditional two-week sprints. In a fast-moving startup environment, two weeks is an eternity. We work in one-week cycles to maintain momentum and ensure we are always aligned with the client's immediate needs. This is a core component of our mvp development framework.

    1. Monday: Planning. We define exactly what we are shipping by Friday. We don't use abstract points; we use tasks. Who is working on what? What is the definition of done for this week?
    2. Wednesday: Sync. A brief check-in. What is blocked? What did we discover that changed our assumptions? We adjust the plan mid-week if necessary.
    3. Friday: Ship and Reflect. We deploy what is ready. We discuss what we learned during the build.

    This rhythm limits total meeting time to under two hours per week. The rest of the time is spent on custom software development. By reducing the ceremony, we maximize the time spent on API development and core logic.

    Stories That Describe Outcomes

    Many teams write user stories that are actually just technical tasks in disguise. We focus on outcome-based stories that answer: "Why would a user want this?" This is essential for what is mvp development because it prevents feature creep.

    Bad story: "As a developer, I want to implement Redis caching so we can reduce database load." Good story: "Users experience 3-second load times on the dashboard. After this work, load times should be under 500ms."

    The good story is superior because:

    • It describes a real user problem (slowness).
    • It includes a measurable outcome (500ms).
    • It doesn't prescribe the solution (maybe we need Redis, or maybe we just need a better SQL index).

    By focusing on outcomes, we avoid over-engineering and stay focused on the six-week MVP delivery strategy.

    Estimates Are Ranges, Not Commitments

    Estimation is inherently uncertain. Software development is a process of discovery. We categorize tasks by confidence levels rather than fixed dates to maintain transparency in our custom software development cost guide:

    • High Confidence: 1-2 days. We have done this before; the path is clear.
    • Medium Confidence: 3-5 days. We know the path, but there are integration variables.
    • Low Confidence: 1-2 weeks. This involves new territory or complex third-party APIs.
    • Unknown: Needs a spike.

    A "spike" is a time-boxed research period (usually 1-2 days) where the goal is not to write production code, but to gather enough information to provide a High or Medium confidence estimate. When stakeholders ask for a timeline, we provide a range based on these confidence levels, ensuring transparency without false promises.

    Continuous Deployment, Not Release Trains

    We do not wait for the end of a sprint to release code. We use a Continuous Deployment (CD) pipeline. Every time a developer merges code into the main branch, it is automatically tested and deployed to production. This is a standard part of our cloud architecture.

    # Example of our deployment flow
    on:
      push:
        branches: [main]
    
    jobs:
      deploy:
        steps:
          - uses: actions/checkout@v4
          - run: npm ci
          - run: npm test
          - run: npm run build
          - uses: cloudflare/pages-action@v1
            with:
              branch: main
    

    To manage this safely, we use feature flags. This allows us to merge code for a new feature without making it visible to users until it is fully ready.

    // Feature flag implementation
    const showNewDashboard = featureFlags.isEnabled('new-dashboard', user.id);
    
    return showNewDashboard ? <NewDashboard /> : <LegacyDashboard />;
    

    This approach reduces the risk of "big bang" releases and allows us to fix bugs immediately rather than waiting for the next "release train." It is particularly effective for SaaS platforms where uptime is critical.

    Retrospectives That Change Things

    Most retrospectives are venting sessions. We keep ours focused on actionable improvement using a strict 20-minute format:

    • What worked? (5 min): We identify successful patterns to repeat.
    • What didn't? (5 min): We list pain points without jumping to solutions.
    • What will we change? (10 min): We pick exactly one thing to change for the following week.

    We assign an owner to that one change. If we try to change five things at once, we usually change nothing. One focused improvement per week leads to massive compounding gains over a six-week project, helping us avoid technical debt.

    Async-First Communication

    Meetings are the most expensive way to communicate. They require everyone to stop their work at the same time. At Kraftwire, we default to asynchronous communication:

    • Questions: Handled via Slack or comments directly in the project management tool.
    • Updates: Written summaries provided in the project dashboard.
    • Decisions: Documented in shared technical design docs.
    • Code Reviews: Detailed written feedback on Pull Requests (PRs).

    We reserve synchronous meetings for high-bandwidth activities: brainstorming architecture, resolving complex conflicts, or building relationships with our clients. This protects the "Flow State" necessary for high-quality custom software.

    Client Collaboration and Transparency

    We don't hide behind project managers. Our clients have direct access to the team building their product. We provide:

    1. Weekly Written Updates: A summary of what was shipped, what is next, and any risks identified.
    2. Bi-Weekly Demos: We show working software, never just slide decks.
    3. Shared Slack/Discord: Real-time access for urgent queries.

    This level of transparency prevents scope creep and ensures that the MVP development stays aligned with the business goals of the founder. It is especially important for fintech applications where security and compliance are paramount.

    The Principle Behind the Process

    Process should serve the outcome, not the other way around. If a specific meeting isn't helping us ship better software, we stop having it. If a new tool helps us catch bugs faster, we adopt it. This philosophy is what allows us to deliver production-ready MVPs in six weeks.

    Our agile approach is designed for speed, quality, and clarity. Whether we are building a SaaS platform or a Fintech application, the goal remains the same: shipping production-ready software that solves real problems for real users.

    Agile is supposed to be adaptive. We take that literally. By stripping away the theatre, we focus on what matters: your product. This lean mvp framework ensures that we don't just build software, but we build the right software for your market.

    Scaling the Framework

    As projects grow from a six-week MVP to a full-scale platform, our approach evolves but the core principles remain. We focus on database design patterns that allow for growth without massive refactors. We also ensure that our testing strategy scales alongside the codebase, maintaining the same speed of deployment even as complexity increases.

    By maintaining this lean Agile posture, Kraftwire Software helps startups in the UK, USA, and beyond navigate the transition from MVP to scale without losing the agility that made them successful in the first place.

    FAQ

    How does Kraftwire handle sprint cycles?

    We work in one-week cycles rather than two-week sprints. This includes a Monday planning session, a Wednesday sync, and a Friday deployment/reflection. This faster rhythm allows us to adapt quickly to feedback and ensures we are always shipping tangible progress for our clients.

    What is an outcome-based user story?

    We write stories based on user outcomes rather than technical tasks. A good story defines a measurable improvement for the user, such as reducing page load time, rather than specifying the underlying technology. This keeps the team focused on business value rather than over-engineering.

    How do you estimate project timelines?

    We categorize tasks by confidence levels: High (1-2 days), Medium (3-5 days), Low (1-2 weeks), or Unknown. For unknown tasks, we perform a 'spike'—a short research period—to reduce uncertainty before providing a final estimate range to the client.

    What is your deployment strategy?

    We use a Continuous Deployment (CD) pipeline where every code merge is automatically tested and deployed. We use feature flags to gate incomplete features, allowing us to ship code daily without disrupting the user experience or waiting for a scheduled release date.

    How do you handle internal communication?

    We prioritize asynchronous communication via Slack and project documentation to protect developer focus. Meetings are reserved for high-bandwidth collaboration, such as architecture design or complex problem-solving, ensuring that the majority of the week is spent on actual development.

    How do you communicate with clients during development?

    Clients have direct access to the development team and receive weekly written updates and bi-weekly live demos of working software. This transparency ensures that the project remains on track and that the client is always aware of the current status and next steps.