You can now build an AI finance app yourself, with end-to-end workflows automated in about an hour. Sign up at app.lumerahq.com/signup and work with the Lumera coding agent to bring your first AI automation to life.

In my last two posts, I wrote about how finance teams are leaning into coding agents to automate their workflows. Today, I want to give you a blueprint for how to start building.

The apps you'll build in Lumera mostly share the same structure. Understanding it up front will make you a much better user of the coding agent.Across finance workflows, the same three zones show up: inputs, business logic, outputs. You’ll see them in accruals, bank recs, revenue recognition, AP coding, close management, and most other finance processes.

The important part is this: in Lumera, you are not wiring all of this together yourself. You describe the workflow, the context, the review requirements, and the outputs you want. The coding agent figures out how to implement that across deterministic code, AI agents, human review, and the underlying platform components. It scaffolds the system for you.

The blueprint: inputs, business logic, outputs

Every finance workflow can be abstracted into three zones.

Inputs and context. The data and business context the workflow depends on. Your ERP connection, bank feed, vendor inbox, chart of accounts, approval policies, accrual thresholds, prior-period patterns, supporting documents, and internal guidance. Some of this is live data flowing in from systems. Some of it is institutional knowledge your team wants applied consistently every time.

Business logic. The layer that turns inputs into work. It’s where the system decides what rules to apply, where judgment is needed, what should happen automatically, and what should be routed to review.

Outputs. Where the work ships. Draft journal entries, review screens for your team, posted entries in NetSuite, outbound emails, dashboards, and the audit trail that records what happened at each step.

If you understand these three zones, you understand the basic shape of an AI finance app.

The logic layer: agents, code, and humans

The most important zone is the middle one. That’s where the app actually does the work.

A good finance app doesn’t rely on one technique. It combines three.

AI agents handle judgment. Anywhere a strong accountant would need to read, interpret, compare, or decide, an agent can help. Reading a vendor email to determine whether services were delivered. Deciding whether an accrual is needed. Estimating an amount from incomplete support. Researching technical accounting guidance and drafting a memo for non-standard accounting treatment.

Deterministic code handles rules. Anywhere the answer is fully determined by the inputs, code should do the work. Pulling all open POs as of month-end. Applying a GL mapping. Joining current activity to prior-period accruals. Calculating schedules. Summing balances. If the logic is clearly specifiable, it belongs in code.

Humans handle exceptions and material decisions. Humans should review the cases where the stakes are high or the answer is unclear. Items over a materiality threshold. Estimates without invoices. Unusual activity. New vendors without prior patterns. Anything the system flags as low confidence.

In many systems, the builder has to decide this split manually and then stitch everything together. In Lumera, the coding agent makes these implementation decisions for you based on the workflow you describe. It determines where deterministic logic is appropriate, where agentic reasoning is needed, where human review should sit, and which platform components should be created to support that flow.

It’s still useful to understand the pattern. But the reason to understand it is not so you can wire the system by hand. It’s so you can give better instructions, review the design intelligently, and refine the result.

How this gets built in Lumera

The easiest way to think about building in Lumera isn’t as assembling software components one by one. It’s as working with a coding agent that turns workflow requirements into a working finance app.

You are primarily describing what the workflow should do, what context it should use, what should be reviewed, and what should happen at the end. The coding agent figures out how to implement that inside Lumera.

A practical build process looks like this.

1. Describe the workflow.

Start by telling the coding agent what you want the app to do. For example:

I want an app that drafts month-end accrual entries by pulling open POs from NetSuite, reading vendor emails, applying our accrual policy, routing exceptions for review, and posting approved entries back to NetSuite.

That gives the coding agent the core workflow: the inputs, the decision points, the review layer, and the outputs. You don’t need to start by deciding which functions should be deterministic code versus agentic logic, or which platform components need to be created. The coding agent works that out for you.

2. Provide the business context.

Next, give the workflow the context it needs to behave correctly. That can include your chart of accounts, vendor-to-GL mappings, accrual policies, materiality thresholds, review rules, memo conventions, prior examples, and edge cases your team already knows how to handle.

This is one of the most important parts of the build. The coding agent can infer a lot from the workflow description, but the quality of the app still depends heavily on the quality of the business context behind it. The better your policies, examples, and guidance, the better the resulting system will be.

3. Let the coding agent scaffold the system.

Once it has the workflow and the context, the coding agent scaffolds the implementation. It determines how to split the workflow across deterministic code, AI agents, and human review. It sets up the underlying platform components: Collections for structured business context, Skills for reusable instructions, Hooks for routing logic, Integrations for system connectivity, Mailboxes for inbound and outbound communication, front-end surfaces for review and action.

This is one of the main advantages of building in Lumera. You aren’t stitching together infrastructure yourself. You’re specifying the workflow, and the coding agent generates the system around it.

4. Review and refine the first version.

Once the first version is scaffolded, you refine it. That usually means clarifying policies, improving examples, tightening thresholds, adjusting how aggressive the system should be about auto-drafting, or changing what should be routed to review. Sometimes it means correcting business context that was incomplete or ambiguous. Sometimes it means telling the coding agent a step should be more rules-based or more conservative.

This is where understanding the blueprint helps. Not because you need to wire the system yourself, but because it helps you judge whether the coding agent made the right design choices.

5. Test it on historical data.

Before running the app in a live close, test it on a prior period where you already know the right outcomes. This is the fastest way to validate whether the logic, context, review rules, and outputs are behaving correctly. In practice, most early improvements come from refining the instructions, policies, mappings, and examples rather than changing the architecture itself. A couple of passes on historical data will usually tell you whether the app is ready for production use.

What this looks like for accruals

Putting it all together, building an accrual app might look something like this.

You tell the coding agent you want an app that drafts accrual entries using open POs, prior-month accruals, vendor emails, and your accrual policy. You upload your chart of accounts, mapping tables, materiality thresholds, and a few examples of strong accrual entries from prior closes. You specify which cases should be reviewed before posting.

From there, the coding agent decides how to implement the workflow. It may use deterministic logic for recurring accruals with stable patterns. It may use an agent for variable or ambiguous cases. It may create review routing for estimated entries over a threshold or for vendors without prior history. It scaffolds the review screen and wires the approved output back to NetSuite.

You’re still in control of the workflow. But you aren’t hand-building the system step by step.

What good looks like

A good AI finance app isn’t just an assistant layered on top of data. It’s a real operating workflow.

It connects the right systems, applies the right mix of code and judgment, routes the right exceptions to a human, and sends the result where the work actually needs to go. Just as importantly, it does this in a way the team can understand, review, and trust.

That’s the blueprint behind these apps. And in Lumera, the job of the builder isn’t to wire that blueprint together manually. The job of the builder is to architect the solution, describe the workflow clearly, provide the right business context, and guide the coding agent toward the right implementation.

That’s what makes it possible to go from workflow idea to working app in an hour instead of a quarter.

Start building

Sign up at app.lumerahq.com/signup. Pick a workflow that runs every month, costs your team real time, and has a clear owner. Describe it to the coding agent. Upload the policies and examples that capture how your team actually does the work. Review what it scaffolds, refine it, and test it on last period’s data.

Your first version won’t be your best one. But you’ll go from “I’ve heard AI can do this” to “I have an app my team is using” in a single evening.

Join our community of finance builders at https://www.lumerahq.com/community to share what you build!

Sowmya is the CEO and co-founder of Lumera, AI infrastructure for finance teams. She was previously Controller at OpenAI and Rippling, and led Corporate Accounting at Square.

I don’t think this is because AI isn’t powerful enough. I think it’s because we’re pointing it at the wrong part of the workflow.

Watch how work actually gets done

Think about a specific process on your team. Pick the one that makes you wince during close. Maybe it’s bank reconciliation, maybe it’s intercompany, maybe it’s preparing a board deck. Now trace how it actually works. The real version, not the process doc.

Someone pulls a report from NetSuite. Someone else downloads a CSV from the bank portal. A third person digs up a contract from a shared drive. All of this lands in a spreadsheet. That spreadsheet becomes the workbench.

Your team normalizes the data, stitches it together, applies business logic that often lives in someone’s head. They build formulas to get to the number they need. Then they send the result somewhere downstream. Post a journal entry, update a report, send a collections email, flag something for review.

The ERP, the bank, the CRM. Those are your systems of record. They store data. They’re essential. But they are not where the thinking happens.

The thinking happens in the gaps between those systems. In the spreadsheet where someone is contextualizing data from three different sources. In the email thread where someone is chasing down a missing remittance. In the manual process that takes two days every month because nobody has built a real system around it.

You have systems of record. What you don’t have is a system of work.

Where AI in finance actually stands

ERP vendors are making real investments in AI, and some of what they’re shipping is useful.

Chatbots on top of your data. The best implementations use curated semantic layers, validated queries, governed data models. You can get quick answers to ad hoc questions, and that’s a real time saver. But even the best chatbot has a ceiling. For the numbers you care about most, you want a reliable dashboard with drill-down into underlying transactions, not a chat answer you hope is right. Chat is a great interface for exploration. It’s not a great interface for running your close.

AI-enabled processes inside existing systems. Revenue contract review inside an ERP, automated transaction coding, anomaly detection. When your business logic fits neatly into what the vendor has built, this works. But I’ve watched teams get excited about an AI feature, test it against their real data, realize it doesn’t handle their edge cases, and go right back to doing things manually. Complex business logic is the norm, not the exception, and vendor implementations can only cover so much ground before they hit the wall of your specific business.

Connectors and integrations. Your ERP gives you an MCP connector, so now you can pull NetSuite data into a chatbot. This is genuinely cool infrastructure. But having access to the data is table stakes. The question is what you do with it, and a chat window isn’t where your team is going to manage AR aging or build a close deck.

These tools are doing real things. But they all share the same limitation: they’re adding AI to systems of record. And the hardest, most time-consuming work your team does isn’t inside any single system of record. It’s in the space between all of them.

The trust problem

If you can’t explain it to your auditor, it’s not production-ready. That’s the bar in finance, and it’s the part of the AI conversation that gets glossed over the most.

When a controller evaluates any new tool, the first question isn’t “is this cool?” It’s “can I trust the output enough to put my name on it?” If a model is generating a number, how do I validate it? If an agent is coding a transaction to a GL account, what’s the audit trail? If something goes wrong, can I trace back to the decision point and understand why?

Most AI tools available today don’t answer these questions well. And that’s why smart finance teams try them, see the potential, and then quietly go back to the way things were. It’s not resistance to change. It’s a rational response to insufficient controls.

Any serious AI deployment in finance needs full audit trails, human-in-the-loop approvals for high-stakes actions, and the ability for someone other than the original builder to understand what’s happening and why.

What to actually do about it

If you’re a controller, a VP of Finance, or a CFO who’s seen the promise of AI but hasn’t felt the impact, here’s where I’d start.

Pick one workflow that’s painful. A specific process, not a vague statement like “we want to automate month-end close.” Bank reconciliation. Vendor invoice triage. Collections follow-up. Month-end flux analysis. Something your team does repeatedly that eats time.

Then trace the real workflow end to end. Four questions:

What data comes in, and from where? List every source, including the unstructured stuff. The ERP report, the bank CSV, the email attachment, the Slack message explaining why an invoice is higher than expected. The unstructured context is usually the most important.

Who stitches this together, and how? It’s almost always a spreadsheet. Someone normalizing data from different sources, cross-referencing, building the picture that no single system provides.

What reasoning and judgment gets applied? The rules that determine how a transaction should be coded, whether an invoice needs escalation, what the right dunning cadence is for a given customer.

Where does the output go? A journal entry posted to the ERP. An email sent to a customer. A dashboard updated for leadership. A file uploaded for audit.

When you map this out for even one process, you’ll see it clearly. The hardest work is happening in the space between your systems, in spreadsheets and email and institutional memory. That’s where there’s no real system today. And that’s exactly where AI can do the most.

What this looks like when it works well

One team on Lumera was spending two days per month on bank reconciliation. Download bank statements, pull transaction data from NetSuite, open a spreadsheet, match deposits against supporting docs, figure out the right GL accounts and departments based on business rules the team had memorized, then manually key journal entries into the ERP. They built an AI workflow that ingests bank data and supporting documents, applies their specific coding logic, surfaces exceptions for human review, and exports clean journal entries ready for posting. The matching and coding that took two days now happens in minutes. The accountant’s job shifted from data entry to review and approval, which is what it should have been all along.

Another team wanted a custom dashboard on Netsuite data with full drill-down into underlying transactions, built around how they think about cash, not how their ERP thinks about cash. They coded a fully custom live dashboard on Lumera, connected directly to their NetSuite data, with the exact views and drill-downs they needed. No more exporting to Excel every week to build the view manually.

A third team built an AI collections agent that looks at AR aging, applies their dunning logic (gentle reminder vs. firmer follow-up vs. escalation), considers payment history and relationship context, and drafts emails for review. Hours of composing collection emails turned into minutes of reviewing and sending.

In each case, the team started by mapping the real workflow. They identified where context was being assembled manually, where judgment was being applied, and where the output needed to go. Then they built a system of work around that, with the audit trails, approvals, and controls that production finance requires.

The opportunity

The gap between systems has always existed because every company’s business is different. The long tail of finance work, the processes that don’t fit neatly into any single product, is enormous. No platform can anticipate every chart of accounts structure, every allocation methodology, every close process quirk. That’s not a failure of the tools. It’s the nature of the work.

AI is the first technology that can actually operate in that long tail. It can parse unstructured data, apply nuanced business logic, pull context from multiple systems, and generate outputs in the right format for wherever they need to go. But only if you point it at the right problem. Not “add a chatbot to the ERP.” Instead: build a real system of work for the cross-system, high-judgment processes where your team is spending their time today.

Your systems of record aren’t going anywhere. The system of work you’ve never had is what’s ready to be rebuilt.

Sowmya is the CEO and co-founder of Lumera, AI infrastructure for finance teams. She was previously Controller at OpenAI and Rippling, and led Corporate Accounting at Square.

He’s a software engineer. He watched for a minute, then said “you should read this” and sent me a link to Automate the Boring Stuff with Python.

I loved this book because it had practical, real life things you could automate by coding in Python. I learned Python and Ruby, shipped some small apps, and started thinking like a builder. But more than coding, that book changed how I looked at my own work. I started pausing before diving into a task. Not just to get it done, but to ask different questions. Why is this manual? What upstream system is producing data in a format that forces me to clean it every time? If I fix this step, what does that unlock downstream?

That shift in perspective ended up mattering more than any individual thing I built. I could see the inefficiencies clearly. I could even prototype solutions. But I couldn’t get any of it into production at work. I could build a script and run it locally on my laptop, but deploying it into an actual workflow with the right controls, integrations, and approvals was a completely different problem. And that gap, between seeing what should change and having the infrastructure to actually change it, is where everything stalled.

What’s different now

Coding agents can take a description of what you need and produce working software. The learning curve that used to take months has compressed dramatically. But I think the narrative around this moment is slightly off. The technology is impressive, but it was never really the bottleneck. The bottleneck was always access. The people who understand finance workflows deeply enough to know what should change are the same people who historically didn’t have the tools to act on it.

Why we’re building Lumera

I started Lumera because I lived this arc. From that Excel workbook to learning to code to seeing the bigger picture to wanting infrastructure that could actually take these ideas to production. The thesis is straightforward. The people who understand finance workflows should be able to build and deploy real automations. Not prototypes that live on a laptop. Production-grade applications with the controls, integrations, and audit trails that the work actually demands.

You can now go from identifying a broken process to deploying a fix without a six-month IT project in between.

The learning curve isn’t gone, though. You still need to think carefully about controls, about what should be automated versus what needs a human in the loop, about how things fail gracefully when the data is messy. There’s a real layer of auditability, approvals, and compliance that matters here and that most of the AI conversation glosses over. But the learning curve is a domain curve now, not a technical one. And that’s a curve you’re already up.

A renaissance for finance teams

Coding agents paired with production-grade infrastructure to ship real solutions have unlocked a level of creativity and possibility that I don’t think most people in finance have fully grasped yet.

This week, we shipped an app template on Lumera for an AI agent that monitors a team’s shared AP inbox. The agent reads inbound emails, categorizes them based on the nature of the email (invoice, vendor payment inquiry, new vendor onboarding, etc.), assigns a priority level for your review based on email context, checks if the vendor or invoice already exists in your AP system, and drafts a response for you keeping all of your business context in mind.

I’m amazed that this app only took a few hours of focused building on our part, and is now ready for our users to clone into their accounts, further customize by chatting with our coding agent, and then deploy those changes within minutes to their team.

The spirit of “automate the boring stuff” is alive and well. The difference is that now, when you pause and see the process clearly and think “this could be better,” you can do something about it.

Ready to start building? Join the Lumera community

Sowmya is the CEO and co-founder of Lumera, AI infrastructure for finance teams. She was previously Controller at OpenAI and Rippling, and led Corporate Accounting at Square.

If you’d told me two years ago that finance professionals would be among the adopters of AI coding tools, I’d have been skeptical. This is historically one of the most risk-averse, process-driven functions in any organization.

But it actually makes sense when you look at the structure of the work.

Finance sits at the intersection of every system in the company. ERPs, HRISs, CRMs, billing platforms, bank feeds, expense tools. All of it flows through finance eventually. And for decades, the job of connecting these systems has fallen on finance teams themselves, armed with nothing but Excel, VLOOKUPs, and sheer determination.

The “long tail” of finance work, the stuff that doesn’t fit neatly into any vendor’s product, is enormous. Every company has its own chart of accounts structure, its own allocation methodology, its own close process quirks. Standard SaaS tools handle maybe 70% of the work. The remaining 30%? That’s where finance teams have always been left to figure it out on their own.

AI agents are the first technology that actually addresses that 30%. LLMs can parse unstructured data. The Slack message explaining why a vendor invoice is 3x higher than usual. The email thread about a contract amendment. The PDF of a workers’ comp audit. They can apply business logic that’s too nuanced for rules engines. And with the coding capabilities now available, finance professionals can wire these together into tools that actually run.

So they started building. A controller builds a reconciliation agent that matches transactions across three systems. An FP&A analyst creates an automated flux analysis tool that pulls from the GL, compares against budget, and drafts variance explanations. A revenue ops lead wires together an agent that flags at-risk renewals by cross-referencing usage data, support tickets, and payment history.

These aren’t theoretical examples. They’re happening right now.

The problem nobody’s talking about

Here’s where it gets uncomfortable.

Most of these projects live on someone’s laptop. They’re running in individual ChatGPT conversations, local Python scripts, or Claude Code sessions that one person on the team understands.

There’s no audit trail for the decisions the agent makes. No access controls determining who can run it or modify it. No version control. No error handling beyond “it worked when I tested it.” No SOC 2 compliance. No way for internal audit to review what’s happening.

For any other function, this might be manageable. For finance, where every number eventually flows to a financial statement, where SOX compliance isn’t optional, where a single misclassified transaction can cascade into a material weakness, this is a serious problem.

And the gap is only going to widen. The coding tools are getting better every few weeks. Claude Code now has background agents, automatic memories, and plugin ecosystems. Codex is running multi-agent workflows with automations that fire on a schedule. The friction to build something useful is dropping fast. The friction to make it production-ready hasn’t changed at all.

The gap between “it works on my machine” and “it runs our close”

Think about what happened with shadow IT a decade ago. Business teams started adopting SaaS tools without IT’s blessing because the tools were better than what IT was offering. The response wasn’t to ban SaaS. It was to build governance frameworks that enabled safe adoption.

We’re at the same inflection point with AI in finance. Except the stakes are higher. When a finance team deploys an ungoverned AI agent that’s making journal entries or classifying transactions, you’re one bad automation away from a material weakness.

The gap between prototype and production isn’t about making the model smarter. It’s about everything around the model. Audit logging every decision the agent makes. Role-based access controls. Human-in-the-loop approvals for high-stakes actions. Data lineage tracking. Error handling and alerting. Integration security. And the ability for someone who isn’t the original builder to understand what’s happening and why.

This is the problem that keeps me up at night. And it’s the problem we built Lumera to solve.

Introducing the Lumera community

Lumera is the infrastructure layer for finance AI. We’re building the platform that takes your AI agents from prototype to production, with enterprise security, audit trails, and governance built in from Day 1.

But a platform alone isn’t enough. The finance professionals building these tools need each other. They need a place to share what’s working, troubleshoot what isn’t, and collectively figure out what best practices look like for this entirely new category of work.

We just opened early access to the Lumera community.

Here’s what you get as a member:

• Full platform access. Build, test, and deploy finance AI agents with production-grade infrastructure underneath. Connectors for your existing systems. A decision engine that logs every action. Observability so you can actually see what your agents are doing.

• Hands-on help shipping your first agent. Our team will work with you directly to take your most painful manual process and turn it into a production-ready AI workflow. Reconciliations, journal entries, flux analysis, variance reporting. Whatever’s eating your team’s time.

• A community of finance builders who get it. Not a generic AI community. Not a vendor user group. A focused group of finance professionals who are actively building with AI and understand both the technology and the domain.

We’re keeping the first cohort intentionally small. We want to go deep with each member, learn what you’re building, and make sure the platform evolves based on real workflows, not hypothetical use cases.

Who this is for

If you’re a finance professional who’s already experimenting with AI, whether that’s a Python script, a GPT wrapper, or a full agent workflow, and you’ve hit the wall between “cool demo” and “something we can actually rely on.” This is for you.

If you’re a controller or accounting manager who’s seen your team spend days on work that should take hours, and you know there’s a better way but you’re not sure how to get there safely. This is for you.

If you’re an FP&A lead who wants to automate the tedious parts of variance analysis and reporting so your team can focus on actual analysis. This is for you.

If you’ve looked at what these tools can do now, the coding agents, the Excel integrations, the finance-specific skills, and thought “this could transform how we work, if we could just get it to production without creating a compliance nightmare.” This is for you.

Join us

The tools are ready. The question is whether finance teams will adopt them through the front door, with proper governance, audit trails, and security, or through the back door, on someone’s laptop, with no controls at all.

We’re building the infrastructure to make the first option possible. And we want you in the room as we do it.

Join the Lumera community waitlist →

First cohort is limited. If this resonates, don’t wait.

Sowmya is the CEO and co-founder of Lumera, AI infrastructure for finance teams. She was previously Controller at OpenAI and Rippling, and led Corporate Accounting at Square.

That moment is genuinely impressive. The model reads the document correctly, pulls out relevant information, and produces something usable in seconds. It becomes clear very quickly that the technology itself is far more capable than most of us expected.

The problem emerges when that same workflow meets real operations.

Month-end arrives. There are hundreds or thousands of transactions. Documents are coming in through email, shared drives, portals, and uploads. At that point, the copy-and-paste approach stops being helpful. It does not scale, and it does not meaningfully reduce operational risk.

This is where many finance teams are today. They have seen what AI can do in isolation, but they have not yet figured out how to make it work consistently, reliably, and inside the systems where accounting actually happens.

That gap is what we have been focused on closing at Lumera. Book a demo to see it in action.

The Practical Limits of Chatbots

Chatbots and prompt templates are useful tools, but it helps to be clear-eyed about what they actually provide.

At their core, they are capable assistants that wait for a human to bring them work. Someone still has to locate the document, paste it into the tool, select or write the prompt, review the output, and then move the result into a system that matters.

That may save time on an individual task, but it does not materially change the workload for teams dealing with high transaction volume and tight close timelines.

The limitation is not the intelligence of the models. Modern models can read invoices, deposit slips, and notices accurately. They can extract the right data and even reason about context. The limitation is integration.

On their own, chatbots cannot automatically pull documents from inboxes, match extracted data to bank transactions, write entries into a system of record, route exceptions for review, or maintain an audit trail that stands up to scrutiny. Those capabilities are not “nice to have” in finance. They are table stakes.

This is not a prompting problem. It is an infrastructure problem.

What AI at Scale Looks Like in Practice

When we talk about AI at scale, we are not talking about better prompts or more polished chat interfaces. We are talking about systems that do work end to end.

Consider a financial services organization we work with that manages accounting across dozens of entities. Before automation, a large team of accountants was involved in processing cash deposit transactions. Supporting documents arrived through email, shared drives, and uploads. Each document had to be found, read, interpreted, matched to a bank transaction, coded, reviewed, and manually entered into the ERP.

Today, that flow looks very different.

Documents are pulled automatically from wherever they arrive. There is no manual downloading, renaming, or organizing. Each document flows through OCR and an LLM pipeline without human prompting. The system extracts structured data such as transaction type, line items, amounts, and suggested coding, and it reliably distinguishes between different document types and revenue treatments.

Based on that analysis, the system takes action. Deposits are matched to bank transactions. Entries are created in the system of record. Confidence scores determine which items flow through automatically and which require human review.

Accountants are no longer reading every document. They review decisions, approve or correct exceptions, and focus their time on higher-value work. Approved entries are exported directly into the accounting system with a complete, auditable trail.

The outcome is not that people were replaced. It is that the team stopped doing first-pass manual work at scale.

Moving From Assistance to Execution

Over the last two years, a clear progression has emerged in how AI shows up in finance teams.

The first phase focused on answering questions and summarizing documents. Useful, but largely informational.

The second phase involved task-level assistance, such as extracting fields from documents. That reduced effort, but still required significant manual coordination.

The current phase is fundamentally different. AI can now ingest documents automatically, process them through reliable pipelines, take action in core systems, and surface only what truly requires human judgment.

Many teams are still operating between the first two phases. They are experimenting and learning, but they have not embedded AI deeply enough into operations to see a step change in workload.

The reason is not model maturity. The models are ready. What is missing is the connective tissue that makes AI production-grade: integrations, orchestration, monitoring, controls, and reliability.

Custom Software, Without the Old Tradeoffs

A reasonable concern at this point is whether this simply describes custom software development. Historically, building systems like this took many months and required heavy consulting support.

What has changed is the availability of purpose-built infrastructure.

Instead of rebuilding pipelines and integrations from scratch, we deploy on a platform designed specifically for AI-driven finance automation. That includes managed OCR and LLM pipelines, confidence scoring and versioning, human review workflows, bidirectional integrations with systems of record, and operational safeguards designed for finance teams.

This allows systems to be deployed in weeks rather than months, while still meeting the reliability and auditability standards finance teams expect.

AI is Ready for Reasoning and Judgment

One of the more surprising realizations for many finance leaders is that AI is no longer limited to basic data extraction.

From an unstructured document, the system can determine what the document represents, which entity or account it relates to, how it should be coded under defined rules, whether revenue should be deferred, and whether it matches a bank transaction, all while providing transparent confidence scoring.

These are judgment-based decisions. The difference now is that AI can make them consistently, and humans can focus on verification rather than first-pass analysis.

A Question for Finance Leaders

Many finance leaders have already asked their teams to explore AI. Experiments have happened. Copilots have been tested. Prompt libraries may exist.

Have you seen the operational shift that actually removes work from teams at scale?

Based on what we have seen, that shift does not come from better prompts. It comes from embedding AI directly into finance operations so that data is pulled automatically, decisions are made systematically, actions are taken in core systems, and humans are involved where judgment genuinely matters.

That is the work we are focused on.

If this resonates, the next step is not another experiment. It is seeing what execution looks like in practice.

See it in action. Book a demo to see what we can help you automate.

You can now describe what you want in plain English, and Excel not only understands your file but also edits it directly — inserting formulas, building logic, and keeping everything auditable.

I’ve been testing it this week, and it’s genuinely impressive. It understands context from your sheet, applies formulas correctly, and even creates helper tabs that make review and reconciliation easy.

Here are two demos that show what’s possible.

🧮 Demo 1: Headcount Allocation Journal Entry

For this use case, I asked Excel’s agent to take IT expenses and allocate them across departments based on headcount.

It automatically:

• found my journal entry template tab

• inserted debit and credit lines

• made sure the journal entry totals matched the source data tabs

📊 Demo 2: Opex Month-over-Month Flux Analysis

Next, I gave it an operating expense detail for August and September 2025, and asked for a Month-over-Month Flux Analysis.

The agent:

• calculated the $ and % change

• added conditional formatting for large variances

• added flux commentary (a bit verbose out of the box, but fixable with more precise prompting)

• created a chart to show the biggest needle movers

How to Enable Agent Mode

From the launch blog post, Microsoft says:

Agent Mode in Copilot for Excel is available starting today in the Frontier program for Microsoft 365 Copilot licensed customers and Microsoft 365 Personal, Family, and Premium subscribers. Agent Mode works in Excel on the web and is coming soon to desktop. To try it, install the Excel Labs add-in and choose Agent Mode.

⚖️ Trust, but Verify

Agent Mode gives your prompt and file context to an LLM, which then plans and executes actions. That means it’s generating output like a smart preparer, not a final reviewer.

Here’s how to use it safely:

✅ Keep formulas visible. Always ask for formulas so results are auditable.

🔍 Review all outputs. Check totals, signs, and any logic that could affect accounting accuracy.

🧠 Treat it like a junior analyst. It’s fast and capable, but you still need to review the work before you sign off.

Try This Yourself

If you want to experiment:

1. Create a small table: Department | Budget | Actual | Variance.

2. Ask the agent: Calculate variance %, highlight anything above 10%, and summarize the top two drivers.

3. Check the results, click into formulas, and tweak your prompt.

4. Try follow-ups like: Add commentary for the top changes” or “sort by largest variance.

You’ll get a sense of how natural and flexible this workflow feels.

💡 What This Means for Finance Teams

I’m personally very excited to see AI in Excel go from being a Chatbot assistant (i.e. ask questions about my file) to an Agent that can understand context, think about what needs to be done, and then go do it. That’s a huge leap forward in terms of usefulness for every day use cases. This is the first time Excel feels truly collaborative with you. Instead of spending time building out the file, you describe what you want and Agent Mode builds the logic while you focus on analysis and review.

For accounting and finance teams, this bridges the gap between manual prep and automated insight. The key is to design your files with formulas and validations so every agent output stays traceable and audit-ready.

It’s early days, but I’m super excited for where this is going. Try it out and let me know what you think!

This conversation stuck with me because it is not about playbooks. It is about mindset.

Betting on yourself early

Praveer started in investment banking, then joined Dropbox during its early growth years. What he carried forward was not just technical knowledge, but a habit of first principles thinking and figuring things out in the moment.

After a short stint at another startup ended with layoffs, he decided to bet on himself. That led him to Figma, right at the moment the company was turning on monetization.

“I wanted to be the person who could make a decision. Even without the playbook, I felt I could figure it out.”

Scaling finance with the business

When he started, the company didn’t have revenue and bookkeeping was outsourced. Within months, enterprise customers were asking for invoices and custom payment terms. That forced finance to evolve fast.

A/R and collections were the first bottlenecks. Then global payroll, audits, technical accounting, and building a team that could flex between generalist problem solving and specialist depth.

Today, Figma runs a seven-day close, with a tech stack and set of processes that balance speed, scale, and accuracy. The big lesson is that systems and tools help, but the real unlock is building a team of curious generalists who can adapt as the business changes.

Spreadsheets are still the love language

Even with planning tools in place, Praveer is clear that spreadsheets remain irreplaceable. They are flexible, auditable, and the fastest way to test assumptions.

The dream FP&A system is one that combines the structure of a planning tool with the flexibility and transparency of a spreadsheet. Until then, finance leaders will keep doing both.

AI and the finance team of the future

Praveer is intentional about making AI adoption part of the culture. He carved out space for his org to experiment with ChatGPT Enterprise and celebrated the wins that came out of it. From automating board deck consistency checks to creating internal Q&A tools, the team is finding leverage in real work.

His view is that the future profile is accountant plus. Or finance plus. Core domain expertise combined with data fluency, systems thinking, and product sense.

Watch the full episode here

If you are scaling finance in a high-growth company, or trying to figure out what “AI in finance” actually looks like, this episode is worth your time. We cover:

• How to bet on yourself and lean into ambiguity

• What it looks like to scale finance from 25 people to global scale

• Why spreadsheets will always have a place

• How to set the tone for AI adoption across a team

🎥 Watch here: How Praveer runs Figma’s Finance team

At first glance, Fetch Rewards looks like a straightforward consumer app: users snap a picture of a receipt, earn points, and redeem gift cards. But as Sean Han explains in this episode, the underlying business model and its accounting nuances are anything but simple.

A business model with unique accounting challenges

Sean joined Fetch after building treasury and controllership functions at complex businesses like Sunrun, MasterClass, and NerdWallet. He assumed a “cash app” would be easy. Instead, he found:

• Marketplace revenue mechanics. Every advertising campaign creates SKU-level variable consideration, tiered discounts, and complex gross-versus-net analysis for multi-faceted partnerships and deals

• A fast-moving points liability. With more than 12 million monthly active users, Fetch must model breakage and cost-per-point across dozens of gift-card vendors

Building on Netsuite

Fetch implemented NetSuite early on, but key modules like billing, revenue recognition, and fixed assets were missing or misconfigured. Rather than rip and replace with brand new tools, Sean focused on implementing these missing capabilities within Netsuite and prioritizing data connectivity:

1. Workato as middleware. Bi-directional flows now keep Salesforce, Snowflake, Slack, and NetSuite in sync, exposing data mismatches in real time.

2. Specialist apps where they matter. Ramp handles credit cards and A/P; Tesorio handles A/R and collections. Everything posts cleanly back to NetSuite.

3. Workflows inside Slack. Invoice and journal-entry approvals happen in Slack where employees already spend their day.

The takeaway: integrations outperform migrations. A lightweight iPaaS layer and purpose-built tools can deliver enterprise-grade control without a multi-year ERP overhaul.

Where AI already delivers ROI

The biggest impact driver for Fetch was Klarity Automate. Klarity scans every revenue contract, extracts key terms, and reconciles them against Salesforce.

Sean’s adoption playbook is pragmatic: treat AI like a promising new analyst. Provide clean data, review its output, iterate. Perfection isn’t the goal; capacity and consistency are.

Shrinking the close, and what comes next

When Sean joined Fetch, month-end close drifted past Day 25. 18 months later, they’re closing by Day 9 and targeting Day 5 by year-end. They implemented Numeric (close-management tool) to automate flux analysis and streamline reconciliations during close.

Listen to the full episode to hear Sean’s candid views on how a lean accounting team can harness AI, data integrations, and a thoughtfully extended ERP to handle enterprise-grade complexity. I think you’ll come away inspired, and armed with a few ideas to test in your own stack!

“What are some use cases for AI that my finance team can get started with?”

That question makes sense. Most finance teams already have established processes and want to understand where AI can help. Phrased this way, we usually hear familiar ideas: draft memos, perform technical accounting research, run quick data analyses.

These are solid first steps, especially for colleagues who have never used ChatGPT or similar tools at work. Yet after the initial excitement, many teams slide back to their regular routines, and the AI pilot remains an interesting experiment rather than a daily tool.

If that pattern sounds familiar, try a different starting point.

Start with “What is not working for us?”

Spend time, either individually or as a group, identifying the gap between your goals and today’s reality:

• Close timing. Do you need to shorten month-end close by ten days?

• Manual errors. Are high-risk journal entries still keyed by hand?

• Workload. Are late nights becoming normal as you keep the finance machine running?

If the problems are obvious, great. If not, apply a helpful constraint:

“If we had to close revenue on BD+1, what changes would make that possible?”

BD+1 leaves no room for last-minute manual entries. Numbers post automatically on BD0, and the team reviews, adjusts estimates, or books accruals the next day.

Define “good” before you automate

Starting with a real challenge provides clear benefits:

1. Motivation is built in. Everyone already cares about the pain point.

2. The finish line is measurable. For example, “We are done when revenue closes on BD+1.”

3. Effort is transparent. A time-boxed target reveals every manual step that still needs automation.

Consider FP&A. If updating the monthly model takes four hours after accounting finishes, set success as the flash report being ready within 30 minutes. That goal forces a close look at every “quick” spreadsheet tweak that quietly adds up.

Why this approach leads to lasting change

AI can remove manual data entry, automate spreadsheet routines, and streamline reconciliations, but these gains matter only when they address problems your team already feels. When you anchor a project to a real objective, you ensure that:

• The solution tackles a genuine bottleneck.

• The team stays engaged because the outcome matters.

• The improvement endures instead of fading after a brief trial.

So rather than collecting a generic list of AI ideas, start by clarifying what is not working today. Set a concrete target, then explore how AI tools can help you reach it. Once the problem is clear and the goal is specific, the right use case will surface naturally and it will stick.

Live AI Masterclass on June 13

I’m partnering with Angela Liu at GaapSavvy to present an AI Masterclass for Accounting. This is a deep-dive into how finance teams can deploy AI today, full of use cases and implementation examples. We still have some spots left, register here

And now for something new…

Introducing the Lumera Podcast!

In this first episode (36 min), I chatted with Edwine Alphonse, Senior Controller at Ramp, about her early career, her transition to Ramp, and how her team has been able to build a world class organization. She led Ramp’s accounting function during a period of incredible growth and her team is remarkably lean and efficient given the complexity of their business.

Edwine recently left Ramp to start a new venture. Check out her work at yourstartupcpa.com, and subscribe to her newsletter here!

WATCH NOW

With code-generated workflows—whether you’re writing Python yourself or letting ChatGPT do it for you—most of that intermediate plumbing is hidden inside the script. While the latest crop of models have incredible coding abilities, it’s easy to miss an off-by-one date error or an unexpected NULL that silently snowballs into the wrong answer.

The quick fix

Always ask the model for a visual sanity check in the same prompt that builds your output file.

A chart (or even a nicely formatted table) makes it obvious in one glance when something looks off.

Let me show you an example. Imagine you want to write a Python script that generates a deferred revenue waterfall. The script reads an invoice file and builds a deferred-revenue waterfall in Excel. Here’s a sample prompt you could use for this:

You are a Python assistant for accountants.

I have a CSV with columns:
InvoiceID, CustomerID, InvoiceDate, RevenueType
(Software Subscription, Implementation, Support), Amount, TermMonths,
StartDate, EndDate.

Write fully commented Python (pandas + matplotlib) that:

1. Reads the CSV and expands each invoice into monthly revenue-recognition rows  
   • Subscription & Support → straight-line over TermMonths starting StartDate  
   • Implementation → 100 % recognized in StartDate month

2. Produces a summary table of revenue recognized by Month and RevenueType.

3. Builds a deferred-revenue waterfall per ASC 606:  
   BegDeferred + Billings − Recognized = EndDeferred, by Month × RevenueType.

4. Exports the invoice data, recognition summary, and waterfall to an Excel workbook using xlsxwriter.

Let ChatGPT run with that prompt and you’ll get a script that makes the Excel file you need. But you still have to open the workbook and build your checks manually to convince yourself it worked.

Level-up: add visuals to the same script

Add this to the end of your prompt:

5. Create two visuals and save them as PNG *and* embed them in the workbook:  
   • Stacked bar of monthly Revenue Recognized by type  
   • Stacked bar (waterfall style) of Ending Deferred Revenue balances by type

6. Display (show) these visuals when the script finishes.

ChatGPT will regenerate the code, inserting matplotlib calls to create a visual chart.

Using the pictures for a “five-second audit”

I ran the script I got from ChatGPT on a real invoice file and got the chart below.

• You see only two stacked bars—Subscription and Support—but no Implementation.

• That’s a good thing! Implementation revenue is 100 % recognized in month 1, so there is no deferred balance left to plot.

With one glance you’ve confirmed your logic for pattern of recognition is sound. If Implementation had shown up in the waterfall, you’d know something was wrong before you even cracked open the workbook.

Similarly, you can quickly gut check seasonality and other trends you know exist in your data by looking at the output visually.

Tips for getting the most out of code-generated visuals

1. Ask early, ask often: add the visual requirement the first time you prompt so you debug as you build.

2. Start small: run the script on 5 invoices before you throw a larger billing dataset at it.

3. Automate basic reconciliations: add completeness and accuracy checks in a chart or table format to the prompt and ask for these checks to be documented in a summary tab in the output file.

Visuals aren’t just pretty. They create a rapid-feedback loop that lets you inspect the results of the script quickly as you iterate through it. The next time you ask ChatGPT to crank out a Python script, add “give me a chart” to your prompt.

If you are looking to put AI to work for you and your team, consider signing up for this AI Masterclass for Accounting. It is a two hour hands-on workshop with live demos of practical AI applications (ChatGPT and beyond). Click below for details.

Register Now

When ChatGPT launched, I started talking with people across the industry about AI’s role in finance and accounting. What struck me was how theoretical most of those conversations were. One person told me he had been learning about AI and its evolution from big data and statistical regression to machine learning, classifiers, and now generative AI. He was very excited about AI, but admitted that he hadn’t been able to make it actually work for him.

Opening ChatGPT for finance is like staring at a blank spreadsheet.

A spreadsheet is a powerful piece of software. It can handle formulas, pivot tables, links across sheets, charts, and more, but you still have to set it up and tie everything together. Could you learn spreadsheets from a textbook? Maybe. But almost everyone I know learned by working on real files, starting from scratch or copying someone else’s template. Learning ChatGPT is the same.

If you enjoy diving into how the models work, by all means do it. I am fascinated by the “sausage making” too. But if that is your primary learning plan for how to use AI in your work, you are missing an easier path.

How I got started

My personal aha moment came at OpenAI. I joined as Controller in March 2023, a few months after ChatGPT launched. The company was scaling quickly, and our finance team was really small. Within weeks, our manual spreadsheet processes broke. We needed scaled automation, but dedicated engineering resources were scarce, external software was pricey, and months-long implementations were non-starters. We still had to close the books in two weeks.

We turned to ChatGPT and began with small Excel-to-Python script conversions. Over time, the team learned where ChatGPT could speed us up and how to layer in our data and business logic to reach the outcomes we wanted.

Over the last two years, we saw real results:

• We shifted a time-consuming spreadsheet based GPU reporting process to an automated dashboard delivering real-time data.

• We built custom GPT bots to answer questions on AP invoice coding, travel and expense policy, and more.

• We sped up our SOX adoption process, reducing time + consulting spend substantially.

• We moved revenue accounting out of Excel into an automated solution, with many new hires on the revenue team teaching themselves SQL using ChatGPT

The payoff was remarkable: we achieved a month-end close in five business days and operated with a finance team less than twenty percent the size of peer benchmarks.

Where should you start? Pick something you already do easily in Excel. Then list the steps and ask ChatGPT to generate a Python script.

Let’s walk through an example

Suppose auditors want employee salaries by month for the last fiscal year, but your payroll system only shows current salary when you run a report. (Yes, this still happens and it’s endlessly frustrating. I’ll save this rant for another post).

Doing this in Excel

You can’t get the actual report you need, so you find yourself downloading a “change report” giving you all the employee salary changes — imagine you get four columns: employee ID, old salary, new salary, date of change. How do you get to your outcome using Excel? You take your change report and use a bunch of IF conditions and date comparisons to build yourself a “salary by month” view for employees. Then you realize you didn’t think about edge cases (what if an employee ID doesn’t appear on the change report? what if a salary change was effective retroactively?) You do all this and finally ship something respectable to the auditors. A few days later, they come back to you and ask for the same report but for cost centers by month. With despair, you go back to Step 1.

This looked like a pretty trivial problem to handle in Excel at the start. But you realize the formulas need a lot of babysitting, break easily when you change some parameters and each time you open the file, it sinks 45 minutes of your day.

Starting with ChatGPT

Instead of starting in Excel, take your problem and ask ChatGPT to write a Python script that ingests the change report and produces a tidy table. You’ll need to think through the business logic carefully (e.g. do you also need to supply a full employee roster report and ask it to pull salaries from there for people who don’t appear on the change report?) and review the output carefully to make sure it’s working as expected. Yes, this takes some time and back and forth. But the beautiful thing is — it’s a one and done and set up. Next time the auditors ask for a different date range, or a different report field, just tweak slightly and rerun the script.

Example Prompt for this Problem

I have an audit request that requires generating monthly employee salaries for the last fiscal year, but my payroll system only provides current salaries, not historical data. To get around this, I have downloaded a 'salary change report' with the following fields:

• employee_id

• old_salary

• new_salary

• date_of_change

I want a Python script that accomplishes the following:

Script Requirements:

1. Input:

   • Salary change CSV file (as described above).

   • (Optional) Employee roster CSV file containing all employee IDs and their current salaries, to capture employees who don't appear on the salary change report.

2. Output:

   • A tidy, structured table showing each employee’s salary for every month of a specified fiscal year. The final table should have the following columns:

     • employee_id

     • year_month (YYYY-MM)

     • salary

3. Logic to implement:

   • Handle salary changes within the month, assuming changes apply from the date onward within that month.

   • For employees without salary changes during the fiscal year, use the salary from the employee roster (if provided).

4. Flexibility:

   • Allow the user to easily modify parameters such as the date range (fiscal year).

   • Clearly commented and easy-to-read code to facilitate future adjustments (e.g., adding additional fields like cost centers or departments).

5. Output Export:

   • Save the resulting salary-by-month table as a CSV file.

Please include clear comments throughout your code explaining each major step, handle potential errors gracefully, and structure the script so it can be easily adapted if auditors request different views (e.g., cost centers by month, salaries by cost center by month, etc.)

Assume the CSV files will be placed in the same directory as the script for simplicity.

Try this out for yourself

Think of one spreadsheet that you update routinely — perhaps actualizing the financial model or prepping a journal-entry file. Feed column names or dummy data into ChatGPT and build a script. If you get stuck, ask ChatGPT to unblock you. Worried about data privacy? Use fake data; the model does not need real numbers to build the script.

The barrier to using AI at work is mostly in our minds. Look for practical examples, adapt them to your tasks, and experiment. In my view, that is the best way to put AI to work.

First, what “close” really means

For clarity, when I say close I’m bundling everything that the accounting team does before you put a bow on the financial results for the month:

• Posting all journal entries and transactions for the period

• Consolidations & intercompany eliminations

• Flux analysis and account reconciliations

• Building a close packet

Best‑in‑class teams wrap all of that in 4–5 business days (BD + 4/5). I’ve run closes at BD + 15 and BD + 4; life gets dramatically better on the faster side.

Why small teams need speed the most

1. Root-cause mindset over duct-tape fixes: A tight deadline exposes bottlenecks, forces you to automate or redesign them, and keeps process debt from piling up.

2. Relevance of the numbers: Three-week-old results are ancient history in a fast-paced business. A BD+4 close turns finance into real-time decision support, not a historian.

3. Sharper materiality lens: When the clock is ticking, you learn which accounts merit deep dives and which can be estimated with low risk before month-end. That discipline scales.

4. Cleaner balance sheet, fewer buried surprises: Early reconciliations mean oddities surface while memory is fresh, long before they fossilize into “we’ll catch it at year-end” balances.

5. Time for the important work: A BD+15 close leaves you standing on the edge of the next one. Finish in five days and the rest of the month is open for system projects, business partner collaboration, and ad hoc transactions. In many ways, this is the work that actually moves the company forward.

Reality check: Racing the clock by pulling all‑nighters works once. Sustained speed comes from process, tooling, and focus - never heroics. The goal is not to burn out the team. Make realistic goals towards progress.

Eight practical plays that actually work

1. Make fast close a formal performance metric: When BD + 5 is on the scorecard, cross‑functional partners deliver their inputs on time.

2. Publish a living close calendar: Surprises kill cycle time. Share deadlines with FP&A, RevOps, and HR so they lock in their hand-offs.

3. 15‑minute daily stand‑ups during close week: Quick surfacing of blockers keeps the whole team rowing in sync and avoids last-night firefights.

4. Track every post‑close adjustment: Run a blameless root-cause on each one and fix the underlying issue so it never repeats.

5. Team‑wide close retro: What went well, what was “meh,” what broke. Convert items 2 & 3 into action items before the next cycle.

6. Attack the worst bottleneck first: Replace the messiest manual workbooks with automated solutions that can save days of effort during close. If you don’t see meaningful wins, it’s really hard to pull the team out of the vicious cycle of long closes.

7. Serve as Chief Unblocking Officer: Stay close to workpapers to spot pain; then advocate for tools, access, or headcount your team needs.

8. Plan (and celebrate) incremental wins: Drop from BD+15 → BD+10 → BD+7 → BD+5 over a few quarters. Celebrate every step; momentum matters.

Getting started this month

1. Pick one friction point everyone complains about.

2. Assign an owner, a due date before next close, and resources.

3. Share the payoff at the next retro - momentum is contagious.

Fast close isn’t a vanity metric; it’s a force multiplier for a lean accounting team.

• Point solutions solving a niche problem: 1 week

• Tools needing data import/configuration: 2 weeks

• Complex ERPs (yes, really): 1 month

You might think I'm crazy, but I’ve done it. At Rippling, in 2019, I was a one-person accounting team and I implemented Netsuite — including a full data migration from Quickbooks, configuring multiple legal entities, and setting up everything needed for our operational requirements — in 30 days. At OpenAI, we consistently reduced implementation timelines down from 6+ months to weeks.

Why does this approach work? Tight deadlines quickly expose:

1. Whether the software genuinely delivers on its promises.

2. Whether your team truly understands the processes they're automating.

If you're stuck in implementation hell (bad tools, burnt-out teams, endless cycles of implementations gone wrong), you need a total reset. Forget everything you've heard and rebuild your approach from first principles:

1. Pick the Right Champions

Levels and titles don't matter. Find people who:

• Know the existing processes inside-out and understand precisely how the product should behave.

• Are deeply motivated to implement the solution because they've personally felt the pain of not having it.

2. Choose Software Intentionally

It might sound obvious, but it’s surprising how often teams skip this step. Don't trust marketing pitches blindly, don't follow "standard advice" without scrutiny, and don't mimic other companies without careful consideration. Instead:

• Clearly document the problems and processes you need solved.

• Make a precise checklist of essential features and critical integrations.

• Write down specific, real-world test cases you’ll use for User Acceptance Testing (UAT).

If you take demos without doing this homework first, you'll let sales teams control the conversation, and you’ll end up solving the wrong problems.

3. Break Projects into Small Pieces

Beware of vendors promising cathedral-like software systems delivered in one massive build over months or years. Insist on a modular build out, with the first go-live happening in less than 30 days. Quick, small deployments let you:

• Identify issues immediately.

• Learn directly from real-world user feedback.

• Rapidly course-correct and improve.

Waiting a year to ship typically means another year spent fixing hidden problems.

4. Small Teams Move Faster

Forget traditional assumptions about large teams and resources. My most successful implementations were done by small, focused teams of two or three motivated individuals. Small teams deliver results quickly, stay closely aligned, and avoid the inertia of larger groups.

5. Own the Critical Parts

A useful hack: look closely at the vendor's implementation plan and identify the longest and most expensive tasks. Take those in-house.

If you work with an external implementation team, leverage their knowledge and experience in the software tool and treat it as expert advice. Ask them about best practices for configurations and workflow setup.

However, something like data migration is far better managed internally because your team understands your datasets and their nuances better than any external vendor. Tools like ChatGPT can significantly accelerate data cleanup tasks.

Ultimately, software implementations present classic principal-agent problems; there are a lot of opportunities for incentive misalignment between vendors and internal teams. Push aggressively for shorter timelines to reveal these misalignments early and fix them fast.

Aggressive implementation timelines aren't just about speed. They're your strongest indicator of whether you'll succeed.

This matters because programming languages like Python and SQL are powerful tools, especially compared to Excel or Google Sheets. They’re built for speed, efficiency, and accuracy at scale. A few quick examples:

• Processing Huge CSV Files: Python can easily process millions of rows of data in seconds, whereas Excel often freezes or slows dramatically.

• Automating Manual Tasks: Instead of manually cleaning data row by row, Python scripts can automate standardizing formats, handling missing data, and removing duplicates instantly.

• Generating Reports and Reconciliations: SQL queries directly pull data from different sources and automate reports or reconciliations, eliminating repetitive monthly tasks.

• Joining Data from Multiple Systems: SQL quickly combines data from your CRM, ERP, banking, and billing systems, simplifying reconciliations and reporting.

• Forecasting and Modeling: Python provides access to advanced analytics and machine learning, enabling finance teams to create sophisticated forecasts and scenario analyses quickly.

How to Get Started

1. Test Everything Thoroughly

Just like you'd never trust an Excel workbook without checking formulas first, you shouldn't use new code without testing. Create a dedicated test environment where you run AI-generated code on historical data. Verify results carefully—reconcile any differences before running it live in your production environment.

2. Invest in Your Finance Data Infrastructure

The full benefit of coding comes when you have easy access to your finance data. Invest in tools like Fivetran, Airbyte, or other data connectors to move data from sources (QuickBooks, Netsuite, Salesforce, Stripe, banks) into a central data warehouse (Snowflake, BigQuery, Redshift). Once centralized, you can automate complex processes using SQL or Python.

3. Start Small and Local

Getting started doesn’t require a big investment. You can run Python scripts directly on your computer—just like working on a local Excel file. Cursor, VS Code and ChatGPT itself are all helpful tools for writing and executing code. AI tools can help you write, debug, and explain the code clearly, in simple language.

What This Means for You

AI writing code doesn’t replace your role—it elevates it. Your job shifts from repetitive spreadsheet management to defining logic clearly, interpreting results, and optimizing workflows. AI does the heavy lifting; you ensure the business logic is sound.

If you’ve ever struggled with the limits of spreadsheets or wished you could automate routine tasks without becoming a developer, now’s your chance. AI puts powerful, scalable tools in your hands—no coding skills required.

If you want to partner with someone to help identify processes that can be replaced or accelerated by code, schedule an appointment with Lumera for a deep dive into your specific needs and use cases.

Share