Cobbler’s Children No More: Building an Agentic Back Office, Part 1

For decades, consulting firms have lived a quiet irony. We help clients modernize operations, build data platforms, and adopt AI – while our own back offices run on a patchwork of SaaS tools, spreadsheets, and knowledge that lives in people’s heads rather than in systems.

Within the consulting industry, we call this the cobbler’s children syndrome: the shoemaker’s kids go barefoot. It’s not hypocrisy so much as triage. Client work pays the bills. Internal efficiency investments wait. Every mid-market company I’ve worked with – from professional services firms to manufacturers to regional insurers – recognizes the pattern.

The difference now is that agentic AI raises the cost of waiting. When AI could only suggest code or summarize documents, messy data and manual processes were annoying but survivable. When agents can query systems, trigger workflows, and act on your behalf, those cracks stop being inconveniences. They become risk.

So we stopped theorizing and started building. This article – the first in a series – walks through how a mid-size consulting firm is automating its own operations with the same tools, techniques, and disciplines we bring to client engagements: a governed data platform on Databricks and agentic workflows powered by our Symphony methodology.

We set out to build working software, separate agentic hype from real leverage, and document a path for mid-market leaders bombarded with AI automation promises – leaders who share our SaaS sprawl and budget constraints but need a case study with receipts, not rhetoric. If we can’t make it work for DevIQ using the same playbook we bring to clients, we shouldn’t be selling it.

The question isn’t whether AI can automate business operations. It’s whether your organization has the direction, data, and execution discipline to make automation safe, scalable, and worth the investment.

From Copilots to Agents: Why the Rules Changed

The last two years of generative AI followed a familiar arc: demos and copilots embedded in everyday tools, helpful but mostly on the side of the workflow. We’re now at a practical inflection point. AI is moving inside the workflow – assigned work items, triggered automations, multi-step reasoning across systems.

The distinction between assistants and agents matters more every quarter:

• Assistants respond when asked. Humans drive the process.
• Agents pursue goals. They plan steps, call tools, and act – with varying degrees of autonomy.

An assistant can hallucinate a plausible paragraph and a human catches it. An agent that pulls the wrong revenue number from the wrong system, or triggers a billing action on stale data, doesn’t produce a bad paragraph – it produces a bad outcome. Agents should handle repetition; humans should keep approval authority on financial, compliance, and ambiguous decisions.

This is why so many “AI automation” pilots stall. The technology moved faster than the foundation. Companies bolt agents onto fragmented data, undocumented processes, and siloed SaaS applications – then wonder why results are inconsistent, risky, or impossible to govern.

Our thesis, tested on our own operations: the viable path to agentic automation starts with data, not demos. Get direction right. Build the foundation. Then automate with discipline.

Acceleration = Direction + Foundation + Execution

At DevIQ, we frame business transformation around a simple formula:

Acceleration = Direction + Foundation + Execution

Each term is load-bearing. Remove one and the equation collapses.

Direction is strategic clarity: which business functions matter most, what outcomes you’re pursuing, and what you’re not going to automate yet. The first rule of acceleration is to have your direction set correctly. The only thing worse than sitting still is accelerating in the wrong direction.

Foundation is the integrated, governed data layer every decision and automation depends on – not a warehouse slide in a strategy deck, but a living platform where sales, delivery, finance, and operations data can be joined, trusted, and secured. For agentic AI, foundation isn’t optional. Agents don’t intuit which CRM field is canonical or whether last month’s time entries have been reconciled. They inherit whatever truth your platform provides.

Execution is where automation lives: codified processes, orchestrated workflows, AI agents operating within guardrails, and the feedback loops that keep them accurate as the business changes. This is where Symphony – DevIQ’s agentic delivery methodology – enters the story. Symphony is how we turn intent into working automation: structured exploration, explicit specifications, agent-assisted implementation, and human review at the boundaries that matter. We use it with clients. We’re using it on ourselves.

Most AI automation conversations skip straight to Execution – buy a tool, deploy an agent, hope for magic. Our experience, as practitioners and as our own guinea pigs, is that sustainable acceleration runs Direction → Foundation → Execution, with incremental delivery at every stage.

Where to Start: Prioritizing for Impact

Our strategic intent is comprehensive: build a foundation that can eventually support automation across every high-value function in the business. Our delivery approach is incremental – focused wins that prove value, surface data gaps, and fund the next iteration. That isn’t a contradiction. It’s how mid-market companies have to operate.

We don’t have a hundred-person data engineering team or a two-year transformation budget. We have the same constraints most of our clients have – which is exactly why this case study matters.

The prioritization rule we used: look for business functions that are repeated frequently and require significant manual effort. Frequency means automation compounds. Manual effort means humans are doing work that doesn’t require judgment, creativity, or relationship-building.

We mapped DevIQ’s operational landscape into four domains:

1. Revenue and pipeline – CRM, proposals, engagement tracking
2. Delivery and utilization – project management, timekeeping, resource planning
3. Finance and billing – invoicing, revenue recognition, expense management
4. People and compliance – HR, payroll, contracts, policy documents

Every domain shared the same underlying problems: data trapped in SaaS silos, inconsistent definitions across systems, and processes that lived in people’s heads or in heavyweight SOPs that nobody read.

Three principles guide the build: start with data, build quality in from day one, and codify process in software – versioned prompts and executable workflows, not shelfware. Use accelerators where they fit; apply the same quality bar you’d enforce on a client deliverable.

Bottom line: automate frequent, manual work first – time entry reconciliation, utilization reporting, invoice generation, recurring operational reporting. That’s where return on investment arrives fastest, data requirements are clearest, and agent guardrails are easiest to define. Leave infrequent, highly bespoke work for later.

The Data Problem: 40 Apps and No Single Source of Truth

Like most modern businesses, DevIQ’s operational data doesn’t live in one place. It lives everywhere.

At last count, more than 40 subscription services touched how we sell, deliver, bill, and run the company – HubSpot, Harvest, Azure DevOps, QuickBooks, ninety.io, SharePoint, Teams, and dozens more. Some are specific to client delivery work; others are the operational backbone any mid-market company would recognize.

A huge portion of how we run the business lives in semi-structured and unstructured formats – contracts, design documents, meeting recordings, email threads, and Teams chats. The knowledge connecting a CRM deal to a delivery project to an invoice often lives in conversation, not in a database field.

The challenges this creates are universal:

• No single source of truth. Which system owns the customer record? The project status? The approved rate? When systems disagree, humans become the reconciliation layer.
• Siloed data and quality debt. Cross-functional reporting requires manual exports and spreadsheet surgery. Missing fields and stale timestamps are tolerable when a human eyeballs a report – dangerous when an agent acts on the data.
• Mixed formats. Structured tables, JSON events, PDFs, and transcripts all matter – and all need a platform that handles more than tidy rows.
• Governance under pressure. Employees need self-service access to business data. Agents need it too – with stricter guardrails, audit trails, and least-privilege permissions.

Not enterprise-scale volume, but enterprise-scale complexity for a company our size. If this sounds like your world, you’re the audience for this series.

Architecture at a Glance

We chose a lakehouse architecture on Databricks as the foundation for DevIQ’s agentic back office. Part 2 covers the reasoning in depth; at a high level, four requirements drove the decision:

1. Ingest from everything – SaaS connectors, APIs, files, and eventually unstructured content at scale
2. Transform with quality built in – not “load now, fix later”
3. Govern for humans and agents – catalog, lineage, permissions, audit
4. Serve multiple consumption patterns – BI dashboards, advanced analytics, and agentic workflows from the same trusted data

We deliberately avoided a patchwork of one-off integration scripts and disconnected automation flows that drift from the systems of record. Those approaches can win a single battle; they lose when you need governed, joinable, agent-ready data across the whole business.

Unity Catalog isn’t an infrastructure detail – it’s the reason an agent can act on billing data without exposing payroll. Declarative Pipelines are how you make data quality a feature instead of a cleanup project. We’ll unpack Lakeflow Connect versus third-party ELT, connector strategy, and catalog design in Part 2.

Final Takeaway

The cobbler’s children don’t have to go barefoot forever. But the fix isn’t buying an AI agent and hoping it figures out your business. It’s the same discipline that has always separated companies that scale from companies that stall – just accelerated by better tools.

Three things we believe after starting this journey:

1. Direction before speed. Automate the right processes first – high frequency, high manual effort, clear data requirements.
2. Data before agents. An integrated, governed lakehouse isn’t a nice-to-have for a pilot. It’s a prerequisite for a production agentic back office.
3. Incremental beats big-bang. Prove value in weeks, not quarters. Each win funds the next layer and surfaces the data debt you’d otherwise discover too late.

What’s Next in This Series

This article framed the problem, the strategy, and the architectural direction. The next two articles go deep on the components that make agentic automation work in a real mid-market business.

Part 2: The Data Foundation – Why we chose Databricks, how we’re ingesting from dozens of operational sources, how Declarative Pipelines and Unity Catalog enforce quality and governance, and the key decisions we’d make again.

Part 3: Process Automation and Agents – Decomposing workflows for automation, embedding agents in real operational processes, and an honest accounting of what worked, what didn’t, and what’s still more fiction than fact.

If you’re a business leader trying to separate AI signal from noise, start here. If you’re a technologist building the platform your agents will run on, Part 2 is where the work gets real.