Schlagwort: pragmatic

  • To Be Pragmatic: Strategy & Planning

    Why strategy is where pragmatism matters most

    Every downstream decision — design, purchasing, integration, operations — inherits the assumptions set at the strategy stage. A strategy built on speculation („we might be 10x this size in three years“) cascades into over-built systems, inflated budgets, and idle capacity. A strategy with no horizon at all cascades into short-termism, technical debt, and constant firefighting. Pragmatic strategy sits deliberately between these two failure modes, and it’s cheaper to fix here than anywhere downstream — a wrong assumption on a whiteboard costs an afternoon to correct; the same wrong assumption baked into a live platform costs months and real money.

    To Be Pragmatic - Strategy & Planning - The Pragmatic Foundation

    1. Start from business reality, not from technology ambition

    The pragmatic starting question is never „what’s the best architecture?“ It’s:

    • What does the business need to be able to do in the next 12–24 months that it can’t do today?
    • What’s actually broken, slow, or risky right now?
    • What budget and headcount genuinely exist — not what could theoretically be requested?

    A strategy document that opens with „we will adopt a cloud-native, event-driven, microservices architecture“ has already failed the pragmatic test — it states a technology preference before stating a business problem. A pragmatic strategy opens with something like „order processing takes 3 days and loses us 8% of customers; support tickets take 48 hours to route“ — problems, not patterns.

    2. Plan in stages, tied to triggers — not fixed years

    Large enterprises can plan on 3–5 year architecture roadmaps because their growth and market conditions are relatively stable. Companies in the 10–5000 range rarely have that luxury — they pivot, get acquired, double headcount, or lose a major client with little warning. Pragmatic planning replaces calendar-based milestones with trigger-based ones:

    • „When we cross 500 transactions/day, revisit the current batch-processing setup“
    • „When we hire a second country’s team, revisit the single-region identity setup“
    • „When support headcount exceeds 15, revisit the shared-inbox model“

    This does two things: it avoids building capacity you don’t need yet, and it removes the anxiety of „did we forecast correctly for 2029?“ — you’re not forecasting, you’re setting tripwires.

    3. Inventory before you invent

    Before any new system enters the roadmap, pragmatic strategy insists on answering: what do we already have that does this, partially or fully? Mid-size companies accumulate tool sprawl fast — three project management tools because three teams each picked their own, two CRMs from two acquisitions, a reporting tool nobody remembers approving. A strategy phase that skips inventory ends up purchasing solutions to problems that already have half-solutions sitting unused.

    A simple, low-effort version of this: a one-page list of every system in active use, who owns it, what it costs annually, and whether anyone would notice if it disappeared tomorrow. This alone often eliminates 10–20% of planned spend before a single new tool is evaluated.

    4. Involve the people who will live with the decision

    Strategy built only by leadership or only by IT tends to fail in opposite ways — leadership-only strategy underestimates operational cost and complexity; IT-only strategy underestimates business urgency and optimizes for engineering comfort. Pragmatic strategy pulls in:

    • The people who will operate the system day to day (not just approve its budget)
    • The people who will pay for it and need to justify the spend
    • A sample of the people who will actually use it

    This isn’t about consensus-by-committee (which is its own anti-pattern) — it’s about surfacing constraints early that would otherwise appear six months into a project as an unpleasant surprise.

    5. Accept a shorter planning horizon as legitimate


    One of the harder pragmatic disciplines: resisting the pull to plan further ahead than the business itself can reliably see. At this size, „good enough for the next 12–24 months, with a known revisit point“ is not a compromise — it’s the correct level of confidence given how fast the underlying business changes. Over-planning here isn’t rigor; it’s a way of avoiding the discomfort of deciding under uncertainty.

    6. Make trade-offs explicit, in writing, before building starts

    The single highest-leverage habit in pragmatic strategy: writing down, briefly, what you are deliberately not doing and why. Not a 40-page architecture document — a half-page:

    „We are choosing a single shared database over per-team databases because our current team size (6 engineers) doesn’t justify the operational overhead of managing multiple data stores. We will revisit this if the engineering team exceeds ~25 people or if a compliance requirement forces data separation.“

    This one paragraph does more to prevent both over-engineering and future regret than almost any other strategic artifact — it turns an implicit assumption into something that can be checked, challenged, and revisited on purpose rather than discovered by accident.


    A useful test for any strategy decision at this stage: if a smart new hire looked at this plan in eight months, would they understand not just what we chose, but why we chose it over the alternatives, given what we knew and what we had? If the plan can’t pass that test, it isn’t a pragmatic plan — it’s either a wish list or a guess.

  • To Be Pragmatic: Why and How?

    The word pragmatic traces back to the Greek pragma — „a thing done“ — and that is precisely the standard IT systems should be judged by in companies of 10 to 5000 employees: not how elegant an architecture looks on a whiteboard, but how well it gets things done with the budget, team, and time you actually have.

    In IT systems design, pragmatic means optimizing for outcomes achievable with the resources you actually have, not for architectural elegance, technology fashion, or what a Fortune 500 company would do.

    What does „pragmatic“ mean here?

    In IT systems design, pragmatic means optimizing for outcomes achievable with the resources you actually have, not for architectural elegance, technology fashion, or what a Fortune 500 company would do. It means:

    • Solving the problem in front of you, not the problem you might have in five years
    • Choosing „good enough and shippable“ over „perfect and perpetually in progress“
    • Matching complexity of the solution to complexity of the actual need
    • Being willing to use boring, proven technology instead of the newest thing
    • Accepting technical debt consciously, as a trade-off, rather than either ignoring it or refusing to ever incur it

    It’s the opposite of both over-engineering (building for imagined future scale) and cargo-culting (copying practices from big tech companies without the context that made those practices necessary there).

    Why is this necessary? What does it differ from?

    Companies of 10–5000 employees sit in an awkward middle zone:

    • Too big to run everything on ad hoc tools and spreadsheets
    • Too small to have Google’s or a bank’s budget, headcount, or risk tolerance for elaborate platforms

    What pragmatism differs from — three failure modes it corrects:

    1. Enterprise-pattern-itis — copying practices designed for organizations with 50 platform engineers (microservices for a 20-person company, Kubernetes for three servers‘ worth of load, elaborate governance boards for a team that ships weekly). This burns budget and slows everything down for problems you don’t have.
    2. Startup-hack-forever mode — the opposite failure: never revisiting early shortcuts, so by 200 employees the „temporary“ spreadsheet-as-database or single admin’s personal laptop running production is still there, and nobody can safely change anything.
    3. Vendor/consultant-driven decisions — buying whatever a salesperson pitched, or whatever a consultant’s standard template says, rather than what your actual constraints call for.

    Why it matters specifically at this size band:

    • Budgets are real constraints, not rounding errors
    • IT teams are small (often 1–20 people covering everything), so operational complexity has a direct, painful cost
    • The business changes faster than in a large enterprise (growth, pivots, M&A), so rigid big-design-upfront architectures become liabilities
    • There’s rarely a dedicated enterprise architecture function to absorb the cost of bad decisions — mistakes hit revenue and morale directly
    • Vendor lock-in and skill availability matter more, because you can’t just hire a specialist team for every obscure technology choice

    How to be pragmatic — by phase

    Strategy & planning

    • Start from business goals and constraints (budget, headcount, timeline), not from a technology wishlist
    • Build a roadmap in stages tied to actual triggers („when we hit X customers/transactions, revisit Y“), not speculative five-year architecture diagrams
    • Inventory what you already have before buying anything new — reuse and consolidate before adding tools
    • Involve the people who’ll operate and pay for the system, not just those excited to build it
    • Accept „good enough for the next 12–24 months“ as a legitimate planning horizon in a fast-moving company

    Design

    • Default to the simplest architecture that meets known requirements; add complexity only when a concrete, current requirement demands it (not a hypothetical one)
    • Prefer standard, well-documented patterns over clever, novel ones — the on-call engineer at 2am will thank you
    • Design for the team’s actual skill set, not the skill set you wish you had
    • Make integration points and data models simple and explicit; avoid speculative abstraction layers „in case we need to swap X later“
    • Document decisions and trade-offs briefly (a short ADR-style note), not exhaustive architecture books nobody reads

    Purchase & development

    • Buy vs. build: default to buying/configuring for anything not core to your competitive advantage (HR, accounting, ticketing, basic CRM); build only where you need differentiation or where nothing fits
    • Prefer mature, widely-used, well-supported products over niche or bleeding-edge ones — support availability and hiring pool matter
    • Total cost of ownership over sticker price: implementation time, integration cost, training, ongoing licensing, and exit cost
    • Negotiate contracts with an exit path in mind (data export, reasonable notice periods) to avoid lock-in traps
    • Avoid „best of breed for every function“ sprawl — fewer, well-integrated platforms usually beat many best-in-class point solutions at this size

    Integration

    • Prefer a small number of well-understood integration patterns (a handful of APIs, a lightweight iPaaS/middleware, scheduled syncs) over building a bespoke integration platform
    • Avoid point-to-point spaghetti — even a simple hub-and-spoke or a single integration tool pays off quickly once you have more than 3–4 systems talking to each other
    • Use vendor-native integrations and standard connectors before custom code
    • Keep integration logic visible and documented — this is where organizational knowledge silently disappears when one person leaves

    Operation

    • Automate the boring, repetitive, error-prone tasks first (backups, patching, user provisioning) — that’s where pragmatic automation pays off fastest, not exotic self-healing systems
    • Right-size monitoring and alerting: alert on what actually needs human action, not everything technically measurable
    • Build runbooks for common failures instead of tribal knowledge in one person’s head
    • Match your operational model to team size: a 5-person IT team should not be running a bespoke 24/7 NOC-grade setup designed for a 200-person SRE org
    • Revisit and retire tools/processes regularly — pragmatism is also about removing complexity you no longer need, not just avoiding adding it

    Overall strategy for being pragmatic and successful

    1. Tie every technology decision to a business outcome you can state in one sentence. If you can’t, question the decision.
    2. Right-size, don’t minimize or maximize — the goal isn’t „as simple as possible“ or „as robust as possible,“ it’s „matched to actual current and near-term need.“
    3. Prefer reversible decisions when uncertain, and treat irreversible ones (core platform choices, data architecture) with proportionally more rigor.
    4. Timebox analysis — decisions that would take a Fortune 500 company six months of committee work should often take you two weeks. Perfect information is a luxury you don’t have and often don’t need.
    5. Revisit deliberately, not accidentally — set explicit checkpoints to reassess (growth milestones, yearly review), so „temporary“ pragmatic choices don’t silently become permanent liabilities without anyone noticing.
    6. Optimize for the team you have and will realistically be able to hire, not an idealized team.