Duration: 2

Close-cycle data comes from everywhere: the payroll system, the general ledger, the bank. Each system has its own date format, its own way of recording amounts, and its own codes for categories and departments. So nobody has a single, trustworthy view of what's been spent, and the team burns days hunting for the one transaction that doesn't tie out.

In this hands-on lab you'll fix that for Meridian Stay, a fictional global hotel brand, as its finance team closes the books on November 2026. You'll land the raw exports in open Apache Iceberg tables, use Snowflake CoCo to clean and standardize them, match transactions across systems, and surface every discrepancy on a live reconciliation dashboard. Then you'll hand the result to the whole team through Snowflake CoWork, so anyone can ask "What's out of balance this month and why?" and get an answer in seconds.

Duration: 3

To complete this lab, you'll need a Snowflake account. A free Snowflake trial account works well. To open one:

1. Navigate to https://signup.snowflake.com/. This link pre-selects AWS and the US East (Ohio) region for you.

2. Complete the first page of the form.

3. On the next section, set the Snowflake edition to Enterprise (Most popular).

4. Confirm AWS – Amazon Web Services is selected as the cloud provider (pre-filled by the link).

5. Confirm US East (Ohio) is selected as the region (pre-filled by the link).

6. Complete the rest of the form and click Get started.

Duration: 2

You're on the finance operations team at Meridian Stay, and it's the first week of December 2026. The November close is due, and the controller wants every discrepancy identified before the external auditors arrive on December 10.

Last quarter, a $47,000 wire transfer for a conference venue deposit cleared the bank but was never journaled in the general ledger. The auditors flagged it, and the team spent a week tracing it back to a journal entry nobody created. Leadership wants to know: could it happen again, and is anything else missing?

The root cause is simple: the three financial systems don't agree with each other.

1. Land the three exports, exactly as they arrived, in Apache Iceberg tables.
2. Clean them with CoCo into one unified transaction ledger, also stored as Iceberg.
3. Match transactions across systems and flag every discrepancy.
4. See the reconciliation status on a live dashboard that investigates every gap.
5. Ask close-cycle questions in plain language through a Cortex Agent in Snowflake CoWork.

Everything through step 4 runs from a single notebook (lab.ipynb) and a pre-built app in the companion repo. Step 5 is done in the Snowsight UI. Let's get started!

Duration: 5

There are no setup scripts to run and no SQL worksheets to open first. Your first action is to create a Git-backed Workspace that clones the companion repo. The repo contains the notebook you'll run (lab.ipynb), the three financial exports (data/), and the reconciliation dashboard (reconciliation_dashboard/).

Make sure you are signed into your trial account. Confirm your active role is ACCOUNTADMIN.

1. In Snowsight, navigate to Projects >> Workspaces.

2. Click the + icon next to Workspaces/Databases -> Create new Git workspace.

3. Fill out the modal:
   • Repository URL: https://github.com/Snowflake-Labs/expedition-2026-day-3-hol
   • Workspace name: anything you like (e.g., finance-close)
   • API integration: click + / Create new and provide:
     • Name: GITHUB_MERIDIAN_FINANCE_LAB
     • Allowed prefixes: https://github.com/Snowflake-Labs
   • Check Public repository.

4. Click Create.

The Workspace opens with the repo's files visible in the file explorer on the left.

1. In the Workspace file explorer, open lab.ipynb.

2. Click Connect next to the Run button and select Create and connect. Wait for the status bar at the bottom of the notebook to show Connected before proceeding. The first connection can take a few minutes while Snowflake starts the notebook's compute.

3. Set the notebook's active role and warehouse using the role & warehouse picker at the top of the Notebooks editor:

   • Role: ACCOUNTADMIN
   • Warehouse: COMPUTE_WH (the default warehouse in every trial account)

4. Work top-to-bottom through the notebook. Markdown cells explain each step; code cells contain the SQL, some of which you'll generate yourself with CoCo. Run a cell with the play button (or Shift+Enter).

Open the CoCo chat panel from the Workspace toolbar. You'll send it prompts throughout the lab.

The first SQL cell in the notebook (setup) creates the MERIDIAN_STAY_FINANCE database with three schemas:

It also grants the Cortex Agent privileges your role needs later. Run the setup cell before continuing. You should see "Statement executed successfully."

Duration: 7

The first step is to get the raw exports into Snowflake without changing them, so you always have the original to compare against.

Apache Iceberg is an open table format. An Iceberg table's data is stored as Parquet files plus open metadata, so other engines (Spark, Trino, DuckDB, and more) can read the same tables through Snowflake Horizon Catalog. Your financial data stays open instead of being locked into one tool, which matters when the external auditors, a consulting firm, or a shared-services team needs access too.

In this lab you'll use Snowflake-managed Iceberg tables (CATALOG = 'SNOWFLAKE' and EXTERNAL_VOLUME = 'SNOWFLAKE_MANAGED'). Snowflake manages the storage for you, so there's no cloud bucket or IAM setup.

Run the raw_tables cell. It creates:

Run the upload_files Python cell. It copies the three CSVs from the repo's data/ folder into the stage. You should see three files with status UPLOADED.

COPY INTO is Snowflake's bulk-loading command. It reads files from a stage and inserts them into a table, and it works the same way whether the target is a standard table or an Iceberg table.

Send this prompt to CoCo, then compare its SQL against the expected output in the notebook. If it does the same thing, click Allow to run it.

You should see 13, 18, and 18 rows loaded. CoCo may list the columns explicitly, wrap the load in SELECT $1, $2, …, or add MATCH_BY_COLUMN_NAME = NONE. All of these load the columns in file order, so they're fine as long as the row counts match.

Run the peek_raw cell. It shows every row from all three exports side by side, so you can see the problems before you fix them:

You can't reconcile until all three systems speak the same language, and that's next.

Duration: 12

Now you'll turn three messy exports into one unified transaction ledger. This usually takes a finance analyst a full day of spreadsheet work. With CoCo, you describe the rules in plain language and review the SQL it writes.

Before building anything, ask CoCo to compare the three sources. It queries the raw tables itself and shows you how differently each system records the same things.

CoCo should map, for example, F&B to Food & Beverage, MGMT to Management, and GL codes PAY to Payroll, UTIL to Utilities, MAINT to Maintenance, MKTG to Marketing, TRAVEL to Travel, MISC to Office Supplies, INS to Insurance, and PROF to Professional Services. It should also call out the three date formats, the three amount formats, the duplicate payroll row (EMP-102 on 11/15), and the reversed GL entry (JE-2014) along with the original it cancels (JE-2013). The full expected mapping is in the notebook.

In the same CoCo conversation, send this prompt. CoCo reuses the mapping from STEP 2 and writes the SQL. Your SQL may not match the expected output in the notebook word for word, and that's fine; the check cell is what tells you it's right. Click Allow to run it.

Run the check_transactions cell. You should see:

The 9 categories are the 8 standard ones plus Uncategorized for the bank rows, and the 11 departments are the 10 standard ones plus Unknown for the bank rows. CoCo's STEP 2 summary may list fewer, because it only shows the labels it had to change.

If your numbers are different, ask CoCo to fix it rather than editing the SQL yourself:

Run the before_after cell. It shows the rows that needed the most cleaning, as they arrived in RAW and as they are now in CURATED:

A reconciliation gap is a transaction that appears in one system but has no matching entry in another. That's exactly what the auditors found last quarter with the $47,000 wire transfer.

The matching logic: a GL entry and a bank transaction match if they have the same absolute amount and their dates are within 3 days of each other.

Send this prompt to CoCo. Compare the output against the expected output in the notebook, then click Allow to run it.

Run the check_gaps cell. You should see 2 gaps totaling $47,200:

The first gap is the one leadership was afraid of: a $47,000 venue deposit wire, paid on November 12 and never journaled. It's the same kind of miss the auditors flagged last quarter, and it happened again. Someone authorized the payment, but nobody created the GL journal entry. But look at the second one: BK-3018, $200, MONTHLY ACCOUNT SERVICE FEE. This wasn't in anyone's close checklist. You just discovered it because you matched every bank transaction against the GL instead of spot-checking the big ones.

This is the kind of gap that a manual close misses: too small to flag, too regular to question, and exactly the sort of thing that turns into an audit finding when someone finally looks.

Notice what's not in the ledger: the $4,800 conference registration fees (JE-2013) and their reversal (JE-2014). The registration was cancelled and never paid, so neither the charge nor its reversal belongs in November's books. Leave JE-2013 in and Travel spending is overstated by $4,800.

Duration: 9

A table of gaps is useful. A dashboard the whole team can look at during the close meeting is better. The companion repo includes a pre-built Streamlit app that reads from both CURATED.TRANSACTIONS and CURATED.RECONCILIATION_GAPS and shows the reconciliation status for November 2026.

1. In the Workspace file explorer, open reconciliation_dashboard/streamlit_app.py.

2. If a banner says "This file looks like a Streamlit app, but is missing configuration", click Convert to streamlit app. The Workspace adds the configuration files the app needs.

3. Click Run. The app runs privately for you on a container runtime.

The dashboard tells one story from top to bottom:

The dashboard checks the bank against the GL. Payroll needs a check of its own: the payroll register lists each paycheck, while the GL records each pay run as one batch. Instead of writing that check yourself, describe it to CoCo.

With streamlit_app.py open, send this prompt to CoCo:

Review the changes CoCo proposes before you accept them. It should add a new section, not rewrite the code that's already there. Accept the changes and click Run again. You should see a new section like this, with a message that payroll ties out:

The tie-out only works because STEP 3 removed the duplicate payroll row. Left in, James Rivera's second $3,800 paycheck would push the Nov 15 register total to $28,950, $3,800 more than the GL batch.

If the GL column comes out empty, tell CoCo: "The GL payroll batches have a reference ID starting with PAY-BATCH."

Duration: 18

The data is clean and the dashboard is live. Now make it available to everyone, in plain language. You'll create a Semantic View with CoCo, a Cortex Agent backed by it, and ask your questions in Snowflake CoWork. This happens in the Snowsight UI; no SQL is required.

A Semantic View describes your data in business terms: which columns are dimensions (things you filter and group by, like category or department), which are facts (raw values, like amount), and which words people use for them ("expense type" means category, "cost center" means department). It's the bridge that lets Cortex Analyst turn a question like "What's out of balance this month?" into correct SQL.

1. In Snowsight, navigate to AI & ML -> Analyst.

2. Click Create in Workspaces in the top right.

3. Click Create with CoCo. Snowsight opens a new .sv.yaml file, and the CoCo panel asks for a name, a location, and the source tables.

4. Send CoCo this prompt:

5. Allow CoCo to create the Semantic View draft in the Workspace. This creates an editable draft; it does not publish the view yet.

6. Review the draft in the Semantic View editor. Confirm it contains:

   TRANSACTIONS

   • TRANSACTION_ID as the unique key
   • AMOUNT under Facts
   • TRANSACTION_DATE under Time Dimensions
   • Synonyms on CATEGORY (for example, expense type) and DEPARTMENT (for example, cost center)
   • A SOURCE_SYSTEM description that says spending totals use only General Ledger rows

RECONCILIATION_GAPS

Verified queries

Fine to keep: extra synonyms (for example, on GAP_TYPE or SOURCE_SYSTEM), extra descriptions, and metrics such as a total amount. Your exact synonym wording may differ.

Fix before publishing: anything on the list above that's missing or in the wrong place, such as AMOUNT under Dimensions or a SOURCE_SYSTEM description without the General Ledger note. Ask CoCo to fix it, for example "Make AMOUNT a fact on both tables."

7. Click Publish in the top right of the editor. In the dialog, confirm Name CLOSE_RECONCILIATION_SV, Database MERIDIAN_STAY_FINANCE, and Schema ANALYTICS, then click Publish.

Cortex Analyst is Snowflake's text-to-SQL engine; it reads the Semantic View to understand your data. The Cortex Agent receives questions, routes them to Cortex Analyst, and writes the answer.

1. In Snowsight, navigate to AI & ML -> Agent Studio.

2. Click Create agent in the top right.

3. Configure:

   • Database and schema: MERIDIAN_STAY_FINANCE.ANALYTICS
   • Agent object name: CLOSE_RECONCILIATION_AGENT

4. Click Create.

5. Click Configuration near the top of the agent editor.

6. Under the General tab, set:

   • Description: I am the Meridian Stay Close Reconciliation Agent. I answer questions about the November 2026 month-end close across payroll, the general ledger, and the bank statement, flag reconciliation gaps, and help the finance team close faster.
   • Example questions:
     • Are there any reconciliation gaps for November 2026? If so, what's the total dollar amount?
     • What's the largest discrepancy, and which systems does it involve?
     • Show me total general ledger spending by category for November 2026.

7. Under the Instructions tab, set:
   • Orchestration instructions: Whenever you can answer visually with a chart, always choose to generate a chart even if the user didn't ask for one. The payroll register, general ledger, and bank statement record the same money, so for spending totals use only General Ledger entries.
   • Response instructions: Give concise, accurate answers for finance operations. Name specific transactions and include dates, amounts, and source systems when relevant. Always express monetary amounts in USD.

8. Click Tools -> Add semantic view.

9. Configure the tool:

   • Service database & schema: MERIDIAN_STAY_FINANCE.ANALYTICS
   • Select semantic view: CLOSE_RECONCILIATION_SV
   • Name: CLOSE_RECONCILIATION_ANALYST
   • Description: Answers questions about Meridian Stay's November 2026 month-end close reconciliation, transactions, and discrepancies

10. Click Add, then click Save in the top right.

Since you created the agent through the UI, it's already available in Snowflake CoWork.

1. In Snowsight, navigate to AI & ML -> Snowflake CoWork.

2. Select CLOSE_RECONCILIATION_AGENT from the agent list.

3. Ask:

   "Are there any reconciliation gaps for November 2026? If so, what's the total dollar amount?"

The agent should find 2 gaps totaling $47,200: the $47,000 venue deposit wire transfer and the $200 bank service fee.

The first answer tells you what doesn't tie out. Continue the same conversation to find out why and what to do about it, the way an analyst would:

1. Understand the big one. Ask: "Tell me everything about the $47,000 wire transfer. When did it hit the bank, and what was it for?"

   You should see it's BK-3006, dated November 12, described as "WIRE TFR - GRAND BALLROOM VENUE DEPOSIT." It hit the bank but was never journaled in the GL — someone authorized the payment, but nobody created the journal entry.

2. Ask if it will happen again. Ask: "Which of these gaps will happen again next month, and what should we change so it doesn't?"

   The $200 bank service fee is charged every month, so it will come back in December unless someone sets up a recurring journal entry for it. The $47,000 wire was a one-time miss; the fix is a control, such as requiring a journal entry before a wire is released. That's the question leadership asked after last quarter's audit: could it happen again?

3. Check the total picture. Ask: "Show me total general ledger spending by category for November 2026, as a chart."

   You should see Payroll as the largest category ($63,860), followed by Marketing ($27,000) and Maintenance ($25,200, mostly the $22,000 pool resurfacing). The agent should produce a bar chart.

   Why the general ledger? The payroll register, GL, and bank statement record the same money, so a total across all three would count it two or three times. The GL is the book of record for spending.

4. Prove nothing else is missing. Ask: "How much cash left the bank in November, and how much did the general ledger record? Does the difference match the reconciliation gaps?"

   The bank paid out $211,960 and the GL recorded $164,760. The $47,200 difference is exactly the two gaps, so they account for every dollar that's out of balance. That's what the controller needs to hear before the auditors arrive.

5. Turn it into action. Ask: "Draft a short email to the controller explaining the two gaps, the journal entry to post for each before December 10, and how to prevent each one."

   CoWork turns the analysis into a message you could send today. This is the point of the whole lab: anyone on the team can go from "what doesn't tie out?" to "here's what we need to fix" without re-running the reconciliation by hand.

Your results may vary in wording and chart choice. Before acting on an answer, review the SQL and the rows behind it, especially for totals and amounts.

The notebook produced clean, open Iceberg tables. The Semantic View gives them business meaning and the words your team actually uses. The Cortex Agent makes that model available in CoWork, where anyone on the team can go from "is the close ready?" to "what needs to be fixed before the auditors arrive?" without writing a query or waiting on a report.

Duration: 1

Once you've finished the lab, run the teardown cell in the notebook, or execute the following in a SQL worksheet:

Duration: 1

Congratulations! You took Meridian Stay's November close from three disconnected exports to a shared dashboard and an agent anyone can ask, prompting CoCo along the way.