How to Be a Star at Work: 9 Breakthrough Strategies You Need to Succeed

By Robert E. Kelley

11 min read

Why does it matter? Because knowing Excel and being dangerous in Excel are two completely different jobs.

You probably think you know Excel. You open it every day. You've typed a SUM formula. Maybe you've even built a pivot table. That feels like competence — and it is, the same way knowing how to drive feels like understanding automotive engineering. But there's a specific category of professional who doesn't just use Excel: they build things inside it that other people depend on. Automated models. Dynamic dashboards. Valuation frameworks that finance teams run every quarter. The distance between those two people isn't talent or even experience — it's a handful of functions most daily users have genuinely never touched. INDEX MATCH. XNPV. XIRR. Structured table references. VBA automation. Each one is a threshold. Cross enough of them, and you stop being someone who enters data into systems and start being someone who builds the systems. That shift has a salary attached to it. This book is about making it deliberately.

The Feature That Exposes What You Don't Know About Excel

How well do you actually know Excel? Most people would say somewhere between beginner and intermediate — they can enter data, run a SUM, maybe build a chart. That self-assessment sounds reasonable, but it misses something: Excel proficiency is less a continuous spectrum than a series of hard thresholds, and the most important one separates people who use formulas arithmetically from people who use them conditionally.

Here is what the threshold looks like in practice. The IF function takes three arguments: a logical test, what to return when that test is true, and what to return when it's false. Written out: =IF(A1>=60,"Pass","Fail"). If the score in cell A1 clears 60, the cell displays "Pass." Below 60, it displays "Fail." The mechanics take about two minutes to learn. But the underlying move — telling a spreadsheet to make a decision rather than just perform arithmetic — is one most users never make. They manually scan columns, color-code cells, or build separate worksheets for each category. The IF function collapses that entire process into a single cell that replicates itself across thousands of rows instantly.

Cell references have the same binary quality. Most users type coordinates and copy-paste without thinking about what happens to those coordinates in motion. Press F4 once while your cursor is on a cell reference and it becomes absolute: $A$1, locked to that exact cell no matter where you paste the formula. Press it again and only the row locks: A$1. A third press locks only the column: $A1. These are not stylistic choices. They are load-bearing decisions that determine whether a formula scales correctly or produces garbage across an entire grid. You either understand reference locking or you're guessing — and in a spreadsheet a colleague inherits, the difference is visible inside thirty seconds.

What separates a spreadsheet user from a spreadsheet builder is whether they've made this mental shift: a formula can encode judgment, not just math. COUNT and COUNTA look like trivial variants until you see the consequences. COUNT tallies only numeric cells; COUNTA tallies everything — text, errors, blanks formatted as strings. Mix them up in a financial report and your row totals are silently wrong, the kind of wrong that survives three rounds of review because no error message fires. Once you understand that formulas can carry decisions and that cell references behave differently depending on how you've locked them, you stop using Excel as a calculator with a nicer interface. You start building things that work.

One Formula, an Entire Grid: Why Reference Logic Is the Real Multiplier

The clearest demonstration is a 10×10 multiplication table. Enter the numbers 1 through 10 down a column and across a row, then fill the interior grid. The naive approach is typing each product by hand — a hundred cells, a hundred opportunities for error. The builder's approach is a single formula: =$A2*B$1. That one expression, copied across the entire grid, produces every correct product without alteration.

Here is why it works. The dollar sign in $A locks the column to A — as you copy the formula rightward, the multiplier always draws from that source column rather than drifting toward B, C, or D. Meanwhile, B$1 locks the row to 1 — as you copy downward, the header value stays fixed rather than sliding to row 2 or 3. The two locks operate independently, each freezing one axis while leaving the other free to move. Remove either dollar sign and the grid fills with wrong numbers, silently, with no error flag.

Absolute references ($A$1) lock both coordinates — essential when every row needs to point at a single constant, like a tax rate sitting in one cell. Mixed references ($A1 or A$1) lock only one axis, which is what allows a single formula to travel across two dimensions at once. The F4 key cycles through all four states — relative, fully absolute, row-locked, column-locked — so you never have to type the dollar signs manually. One keystroke, repeated until you reach the reference behavior you need.

The builder's insight is not that these features exist. It is that they transform formula design from an arithmetic task into a structural one. You write the logic once, correctly, and let the reference system do the replication. That is not a time-saving trick. It is a different way of thinking about what a spreadsheet is for.

VLOOKUP Will Betray You. Here's What to Use Instead.

VLOOKUP is not the professional standard for data lookup — it is the beginner's approximation of one. Most spreadsheet users discover it early, learn the four arguments, and treat it as a solved problem. The structural flaw only reveals itself when the spreadsheet grows around them.

Here is the flaw: VLOOKUP can only search left to right, starting from the leftmost column of the table. If your lookup key sits anywhere else — say, you want to search by price and return a fruit name, but price is in the right column — the function fails outright. No partial result, no workaround within the formula itself. Wrong column order, broken lookup. This is not an edge case. It is constant friction in real data, which rarely arrives pre-sorted for VLOOKUP's convenience.

The second failure is quieter and more dangerous. VLOOKUP identifies its output column by a hard-coded number: column 3, column 5, whatever you specified when you wrote it. That number does not update when your spreadsheet changes. Add a column to your table, and every VLOOKUP referencing columns beyond the insertion point now returns data from the wrong place — no error message, no red flag, just silently incorrect numbers propagating through your model. In a financial report, that is the kind of mistake that travels far before anyone catches it.

INDEX MATCH exists precisely because these failure modes are unacceptable in serious work. MATCH locates where a value appears in a range and returns its position; INDEX uses that position to retrieve a value from any corresponding range. The search runs in any direction. The output column is defined by a cell range, not a hard-coded number, so adding columns to a table does not disturb it. Written out: =INDEX(C3:E9, MATCH(B13,C3:C9,0), MATCH(B14,C3:E3,0)) — one MATCH finds the right row, another finds the right column, INDEX returns the value at their intersection. More complex to write once; immune to the failures that quietly corrupt simpler formulas over time.

A spreadsheet built on VLOOKUP is fragile by design. A colleague reorganizes the data, the model breaks invisibly, and nobody catches it until the deck is already sent. A spreadsheet built on INDEX MATCH is durable. That is the whole argument.

The Silent Error in Every NPV Model Built Without Dates

Standard NPV is wrong by design whenever your cash flows don't arrive at perfectly equal intervals — and in real deals, they almost never do. The function assumes you're discounting payments spaced exactly one period apart. Feed it a model where an investment closes in January, a draw happens in April, and a return comes eleven months later, and the math proceeds as if those gaps don't exist. The number it produces is precise to the decimal and quietly incorrect.

XNPV solves this by treating dates as an explicit input rather than an assumption buried in the formula's architecture. Instead of passing in a discount rate and a series of cash flows, you pass in a discount rate, cash flows, and the actual calendar date attached to each one. The function discounts each flow by the exact fraction of a year between that date and the start date. The result is what the deal is actually worth, not what it would be worth if every payment happened to land on schedule in equal increments.

The difference isn't theoretical. A real estate model, a private equity waterfall, a project finance structure — any of these will have irregular timing. When the spacing is uneven and the amounts are large, the gap between NPV and XNPV moves the headline number enough to matter to the people signing the term sheet. XIRR carries the same logic into internal rate of return: it solves for the discount rate that zeros out your XNPV, with dates attached, rather than assuming the periods are uniform.

XNPV and XIRR aren't advanced features — they're the baseline for any discounted cash flow work that has to hold up.

Dynamic vs. Static: The Architectural Choice That Determines Whether Your Model Ages Well

The architectural version of a self-maintaining system in Excel is a Table — activated with Ctrl+T on any data range. The transformation looks cosmetic at first: alternating row colors, a filter dropdown on each header. What actually changes is how the spreadsheet references its own data. A standard range uses coordinates: A1:B10. Those coordinates are frozen. Rename a column, insert a row, extend the data by fifty entries, and every formula pointing at that range either breaks silently or requires manual correction. An Excel Table replaces coordinates with names. A column called "Total" is referenced as [Total] everywhere it appears. Rename it, and every formula updates automatically. Extend the table, and every formula covers the new rows. The logic travels with the structure instead of anchoring to a fixed address that the structure eventually outgrows.

This is the architectural choice the prior sections were building toward. You learned to encode judgment with IF, to look up data without fragile column counts using INDEX MATCH, and to discount cash flows with their actual dates using XNPV. Each of those moves replaced a tool that worked until the model touched reality. Excel Tables make the same swap at the structural level: instead of a grid of cells you manually maintain, you have a dynamic object that maintains itself.

The practical payoff shows up in two places. First, formulas become auditable. A colleague inheriting your model reads [Unit Price] and [Quantity] and understands immediately what the calculation does. They read D4*F4 and have to trace coordinates to figure it out — and trace them again after any reorganization. Second, growth is free. Add a row of new data below the table and every summary formula, every chart drawing from that table, every calculated column extends automatically. The model scales without your involvement because the logic was designed to travel, not to sit still.

What Financial Modeling Actually Requires (The Stack No One Lists on a Job Description)

What does it actually take to build a financial model that a deal team will trust? The honest answer is blunter than most job descriptions: five distinct skill layers, and Excel is the last one listed for a reason.

The stack runs from accounting through financial mathematics, market analysis, and the synthetic judgment to blend them — with Excel as the execution layer at the top. That ordering matters. Excel proficiency without the layers beneath it produces a spreadsheet that looks rigorous and calculates nonsense. The tool is only as good as the analytical framework loaded into it.

The clearest illustration is how Comparable Company Analysis — Comps — actually works. The mechanics fit in one sentence: if Company X trades at ten times its earnings per share and Company Y earns $2.50 per share, Company Y is worth $25.00 a share, assuming the companies are genuinely similar. But everything load-bearing happens before you open a file. Deciding which companies count as comparable, understanding what EV/EBITDA signals that P/E doesn't, knowing whether a multiple reflects a sector premium or a one-time event — that is accounting and market analysis doing their work. Excel executes the conclusion. It doesn't produce it. DCF modeling makes the same dependency structure visible at greater scale, because the method forces every assumption into the open rather than embedding them in a comparables selection.

DCF requires pulling three to five years of historical financials, linking the income statement, balance sheet, and cash flow statement into a coherent model, projecting forward under explicit assumptions, estimating a Weighted Average Cost of Capital, and discounting the entire projection — including a terminal value — back to the present. It is the most precise of the three standard methods for exactly that reason. It is also the most dangerous in inexperienced hands: the Excel arithmetic completes regardless of whether the assumptions behind it are defensible. Garbage in, polished output.

The career implication is direct. Analysts who treat Excel as the credential are hirable. Analysts who understand it as the final layer of a five-part stack are the ones whose models get used when the deal closes.

Automation Isn't Magic — It's Knowing Where Excel's Constraints Live

Marco spends an afternoon setting up a data entry form for his team — a clean table, proper headers, the Form button wired to the Quick Access Toolbar. He tests it on his own machine. It works. He hands it off. His colleague opens it, clicks the button, and nothing happens. The table starts at B2, not A1, and isn't named "database." Excel's form feature has a hard constraint baked into its architecture: it works exactly as advertised under two specific conditions and silently fails everywhere else.

The difference between a macro recorder and someone who actually knows VBA lives precisely here. A recorder captures clicks. A developer understands where the tool breaks and routes around it. The fix for Marco's problem is three steps disguised as code: before opening the form, programmatically name the active table's range "database," call the form, then delete that name once the form closes. The constraint isn't removed — it's satisfied temporarily, on the fly, without the user knowing it ever existed. That's not recording a macro. That's understanding what the tool checks before it runs and feeding it what it needs.

The number-to-words converter makes the same point from the other direction. Producing "three thousand two hundred seventy-eight" from 3278 requires a two-function system: one handles large-scale groupings (thousands, millions, billions), another resolves the irregular teens using a Select Case block for each edge case. Excel has no built-in path to that output — and there's no constraint to route around, because there's no feature at all. You build the logic or you don't get the result. Both cases land in the same place: meaningful automation requires knowing what the tool can and can't do, then writing code that covers the gap.

Leave with one recalibration: automation is not a button. It's knowing which constraints the tool enforces, deciding which ones you can satisfy programmatically, and writing the code that does it. That's learnable — but only once you stop expecting the recorder to do the thinking.

The Career Gap Is Real, and It's Measured in Specific Numbers

The demand for analytical workers has already outpaced supply by a margin that changes your negotiating position whether you realize it or not. IBM and McKinsey jointly estimated that nearly 2.8 million analytically skilled roles needed filling in the United States by 2020 and 2021. Market research analysts specifically were projected to grow at 18 percent — one of the highest rates across any professional category. That gap doesn't close when you read a statistic about it. It closes when someone who can actually do the work walks into a hiring conversation.

The salary data makes the premium concrete. Entry-level analysts start around $83,750. Senior analysts command between $118,750 and $142,500. In sectors like mining and natural resources, junior roles already clear $100,000. These are not aspirational figures. They are the market's current answer to the question of what analytical fluency is worth when it's scarce.

The skills covered throughout this material — conditional logic, structured references, durable lookups, date-accurate discounting, self-extending tables, and programmable automation — are precisely the capabilities that separate candidates in that labor market. Excel is not the credential. Excel competence at the level described here is the credential, and the gap between someone who can enter data and someone who can build a model that holds up under real conditions is what those salary bands are measuring.

You now have the scaffold. The gap is real, the numbers are documented, and the tools are learnable. The people on the high side of that salary range didn't get there by using Excel the way most people use it. They got there by learning to write logic that survives edge cases, lock references that don't break under pressure, discount cash flows to the correct date, and automate the work that used to eat the afternoon. That's the threshold. You've spent the last eight sections learning exactly what it looks like.

The Difference Between Knowing the Tool and Being the Person Others Depend On

When you build the model the whole team runs their numbers through, you've created something closer to infrastructure than a spreadsheet. The functions are replaceable — Microsoft will deprecate some, improve others, competitors will clone the rest. The person who built the system isn't. That's an engineering skill: designing something dynamic enough to absorb change without breaking, transparent enough that a skeptical colleague can trace every assumption back to its source, reliable enough that leadership stops double-checking the output. It encodes your judgment, survives your absence, and keeps running long after the meeting where it was first opened. The syntax is just the material you worked with.