Discover creators and exclusive content on Sociala

I keep seeing teams burn weeks on fine-tuning when the actual issue is much simpler:

the model never had access to the right information in the first place.

That’s why the whole “RAG vs. fine-tuning” debate usually starts from the wrong premise. They’re not interchangeable tools. They solve different failure modes.

RAG changes the evidence available at answer time.

Fine-tuning changes the model’s learned behavior.

If you miss that distinction, you can understand both techniques reasonably well and still ship the wrong architecture.

A practical way to think about it is an internal employee assistant.

Say it answers questions about benefits, security procedures, or company policy. It gives the wrong answer about parental leave because the policy changed last week. I’ve watched too many teams jump straight to: “Let’s fine-tune the model on all our docs.”

That’s usually the wrong move.

If the problem is that the answer depends on private or fast-changing information, you do not want to bake that into weights and then retrain every time reality changes. You want retrieval. Update the docs, refresh the index, and move on.

That’s the core case for RAG: current, source-grounded, external knowledge.

But I also liked the reminder that RAG is not magic. A lot of bad AI systems are just bad retrieval systems wearing an LLM costume.

If retrieval pulls last year’s policy, the model can still produce a polished, cited, completely wrong answer. And that failure mode is nasty because it looks trustworthy. So when people say “we have RAG,” my next question is usually: great, but how good is your chunking, filtering, ranking, metadata strategy, and retrieval eval?

A vector database is not a reliability strategy.

Then there’s the opposite case: the system already has the right information, but the output is inconsistent.

Maybe it needs to produce valid JSON every time. Maybe it must classify tickets into a fixed set of categories. Maybe it needs to follow a very specific response pattern for downstream automation.

That is not primarily a knowledge problem. That’s a behavior control problem.

And this is where teams also overreach. They hear “behavior problem” and jump straight to fine-tuning, when a lot of the time the right answer is just better constraints:

• prompting
• structured outputs
• schemas
• validation
• guardrails

This is one of those deeply unsexy production truths: if your app can deterministically enforce output shape, do that before you train a model to probably behave.

I’m extremely aligned with the rule of thumb here:

Retrieve, constrain, train.

In that order.

First ask: does the answer depend on information that changes, stays private, or lives outside the model? If yes, start with RAG.

Then ask: does the model need to respond in a more consistent, specialized, or tightly controlled way? If yes, start with constraints and only evaluate fine-tuning if those controls still fall short.

That sequencing matters because a lot of “fine-tuning needs” disappear once you clean up retrieval and enforce structure.

The other useful point is that some systems obviously need both.

A compliance assistant, for example, may need current regulations and an approved risk-assessment format. That’s not a philosophical debate. It’s just two separate jobs in one pipeline:

• retrieve the current evidence
• constrain the output format
• fine-tune only if there’s still a real behavior gap left after evaluation

That’s a much better framing than the usual vendor-slide nonsense where one technique is presented as the silver bullet.

What I’d actually save from this is the diagnostic test:

No information? Retrieve it.
Wrong output shape? Constrain it.
Correct information and structure, but weak task behavior? Then evaluate fine-tuning.

That’s the level of specificity I wish more AI architecture conversations had.

Because most production failures are not caused by “AI being immature.” They’re caused by teams solving the wrong layer of the problem.

A lot of teams talk about monoliths vs microservices as if the deployment model is the whole story.

It isn’t.

What matters much earlier is whether your system has real internal boundaries.

That’s why I think the distinction between a regular monolith and a modular monolith is so useful. Both are still a single deployment unit. Both can be clean. Both can be well-structured. But a modular monolith is stricter about one thing that becomes existential as a system grows:

who is allowed to know what, and how they are allowed to know it.

In a normal monolith, you can absolutely start with good intentions. Nice folders. Clean Architecture. Separate layers. Feature organization. Everything looks tidy in year one.

Then reality shows up.

A handler in one area reaches into another domain “just for now.” A query joins across tables because it’s convenient. One team reuses another team’s entity because it saves a little time. None of these decisions feel catastrophic in isolation.

But I’ve seen this movie enough times to know how it ends: the codebase still compiles, still ships, and still gets more expensive to change.

That’s the core problem. Coupling doesn’t usually arrive as a dramatic architectural mistake. It sneaks in through convenience.

A modular monolith is an attempt to put guardrails around that tendency.

What I like about the model is that it forces a more honest definition of a module. A module is not just a folder. It’s not a naming convention. It’s not a section in the repo that everybody politely agrees not to touch.

A real module has:

• clear ownership
• internal implementation details
• a public contract
• controlled touchpoints with the rest of the system

That shift matters.

Once teams are required to go through a module’s public API instead of reaching directly into its internals, the architecture gets more intentional. You stop leaking entities across the system. You stop creating accidental dependencies that nobody meant to design. You start making coupling visible.

And visible coupling is manageable coupling.

I also like the database angle here, because this is where a lot of otherwise “clean” monoliths quietly fall apart.

At the application layer, teams often talk about boundaries. At the database layer, they ignore them completely. Shared tables, cross-schema joins, direct reads into another domain’s data — all of it works, until one day it doesn’t.

Database coupling is some of the hardest coupling to unwind because it gets normalized. It feels efficient. It feels pragmatic. And then later it becomes the reason nothing can move independently.

That’s why schema or persistence isolation inside a modular monolith is more than a technical nicety. It reinforces the same principle as the code structure: access should be intentional, not incidental.

Now, I don’t think this means every monolith needs the full modular monolith treatment on day one.

In fact, I’d be cautious about over-engineering too early. Strong boundaries come with upfront cost. You’re creating more explicit seams, more contracts, more discipline. If the product is still searching for basic fit, that may be more ceremony than value.

But once the system starts growing, once multiple teams are involved, once the business domains begin to stabilize, those boundaries stop feeling theoretical. They become leverage.

That’s the real strategic benefit for me.

A modular monolith gives you many of the advantages people chase with microservices — clearer ownership, better isolation, easier extraction later — without immediately paying the tax of distributed systems.

And that tax is real.

I’ve watched plenty of organizations adopt microservices when what they actually needed was better modularity. They thought the answer was network boundaries. The real problem was they never established architectural boundaries in the first place.

If your internals are tangled, splitting the deployment just spreads the tangle across the network.

So when I look at monolith vs modular monolith, I don’t see a religious debate. I see a maturity question:

Are we serious about boundaries, or are we just hoping folder structure will save us?

For most teams, a well-designed modular monolith is a very strong answer. It keeps operational complexity low while forcing architectural discipline where it matters most.

And if you ever do need to extract a module into its own service later, you’re not starting from chaos. You’re starting from a system that already learned how to separate concerns.

That’s a much better place to be.

I have rewritten resumes for professionals in every age bracket, and I can say this plainly: there is something deeply broken about a hiring market that makes experienced people feel like they need to apologize for having experience.

When I hear someone say, “I’m 55 and I can’t find a job,” I do not hear lack of work ethic. I do not hear lack of capability. I hear the collision between a seasoned professional and a modern hiring process built for filters, optics, and conformity.

That distinction matters.

For many Gen X professionals, work used to be more human. You met people. You shook hands. You proved yourself through judgment, reliability, and results. Now the process often starts with an ATS, continues through keyword theater, and ends in silence. Upload the resume. Re-enter the resume. Submit. Wait. Get ghosted.

It is not just frustrating. It is corrosive.

The most troubling part is the advice many over-50 candidates receive. Age-proof your resume. Remove dates. Compress your history. Make yourself look current. Sound younger. Strip away the very evidence that you know what you are doing.

As a resume writer, I believe in strategy. I do not believe in self-erasure.

Yes, resumes should be edited. Yes, older experience should be curated. No, a resume should not read like a memoir. But there is a significant difference between focusing a career story and hiding it.

That is where too much advice goes off the rails.

A strong resume is sales copy. It should position value, control narrative, and make the next step easy for the buyer. But if the strategy requires a candidate to disguise maturity, downplay depth, or flatten a 30-year career into something artificially junior, the market is not rewarding merit. It is rewarding camouflage.

And that brings me to LinkedIn.

I have spent enough time on that platform to know it often confuses branding with performance. Everyone is “humbled,” “thrilled,” and “excited to announce.” Everyone is leveraging synergies, moving needles, and embracing their next chapter. The language is polished to the point of absurdity.

My issue is not professionalism. My issue is synthetic sameness.

We tell professionals to stand out, then coach them to sound exactly like everyone else. We say “be authentic,” then hand them a script. We say “show personality,” then penalize plain speech. For experienced workers, especially those over 50, that dynamic can feel especially alienating because they have already spent decades becoming someone. Now they are being told to repackage themselves into corporate-safe language that says very little and sells even less.

I have a strong opinion here: jargon is not strategy.

If a resume says “leveraged cross-functional synergies to drive impactful outcomes,” I learn almost nothing. If it says “cut operating costs 18% across three departments by redesigning vendor workflows,” now I have evidence. Specificity wins. Substance wins. Clear verbs win.

That applies at every age.

The broader question underneath all of this is the one I find most important: When did experience become something people feel pressured to hide?

Experience should signal pattern recognition, resilience, decision quality, and speed to contribution. It should mean fewer training wheels, better judgment, and more mature problem-solving. If the market increasingly reads it as expensive, outdated, or difficult to place, then employers need to examine the lens they are using.

To be fair, age is not the only factor in a difficult job search. The market is tight. Competition is real. Hiring is slower. But when highly capable professionals with long records of work start wondering whether their experience has become a liability, that is not an individual confidence problem. That is a market signal.

If you are over 50 and navigating this, my advice is practical:

Do not submit a bloated resume full of legacy detail that dilutes your relevance.
Do not lead with chronology when you should lead with value.
Do not let old titles carry more weight than current capability.

But also: do not erase your credibility to look more palatable.

The answer is not to become smaller. The answer is to become sharper.

That means a resume built around results, not duties. A LinkedIn profile written in human language, not corporate costume. A narrative that makes your experience feel commercially useful now, not merely impressive then.

And for some professionals, there is an even bigger question worth asking: if the gatekeepers do not recognize the value, what do you build next?

I think that is where this conversation gets interesting. At 55, 58, 62, the goal may not simply be “get hired.” It may be to decide whether your next chapter is employment, consulting, freelance work, a small business, portfolio work, or something you have not named yet.

That is not defeat. That is career ownership.

I do not think professionals over 50 are done. I think many are being forced to renegotiate how their value gets packaged, perceived, and paid for. Those are not the same thing.

And if hiring systems have forgotten what experience looks like, then experienced professionals need to stop writing like applicants asking for permission and start positioning themselves like assets worth buying.

That shift changes everything.

If you are over 50 and job searching, I would be interested in your experience. Are you seeing ageism directly, or are you seeing a process that simply no longer knows how to evaluate seasoned talent?

I keep coming back to a simple truth: comp plans are behavior design.

If you pay for the wrong thing, you will absolutely get the wrong motion. The cobra bounty story is the perfect analogy for sales comp: reward dead snakes, and eventually someone starts breeding snakes.

That’s exactly what happens when companies bolt old-school SaaS compensation onto a consumption-based GTM.

In a subscription model, the rep can close the deal, book ARR, and move on. In a consumption model, the “close” is often just the starting line. Value realization, adoption, expansion, and retention are all downstream of that initial land.

That changes everything.

What stood out to me most is that usage-based pricing doesn’t just force a pricing rethink. It forces a role design rethink.

The clean handoff between sales and post-sales gets blurry fast. In a consumption motion, growth is shared across AEs, CSMs, solutions architects, product, and sometimes PLG. If you don’t redefine swim lanes, you end up with a classic attribution mess:

• what was organic growth?
• what was sales-assisted?
• what should a rep actually get paid on?

That’s where a lot of teams get into trouble. They compensate on revenue that would have happened anyway, then wonder why CAC payback stretches and rep productivity becomes noisy.

The part I really liked was the emphasis on measuring reps on what they can actually control.

That sounds obvious, but most companies don’t do it well. In consumption, macro and customer behavior can swamp rep effort. A customer can spike because their business is booming, or contract because their market falls apart. If comp is tied too tightly to raw usage without context, you’re basically paying commission on externalities.

From a growth/operator lens, that’s dangerous because it creates two bad outcomes at once:

you overpay for non-incremental growth, and under-incentivize the hard work of creating new demand.

The most sophisticated idea here, in my view, is the need for actual instrumentation between product usage and CRM. That’s the unlock.

If you can tag workloads, products, teams, or use cases back to opportunities, you can start separating:

• baseline / organic consumption
• sales-sourced expansion
• new workload adoption
• retention / protection work

That’s where a modern RevOps org has to go. This isn’t just comp design anymore. It’s data architecture for GTM.

I also loved the control-group thinking: leave a subset of self-serve customers untouched, compare their growth curve to rep-touched accounts, and use that delta to estimate sales impact.

That’s a very growth-style approach, and honestly, more SaaS companies should borrow from experimentation discipline here. Too many orgs treat sales contribution as a given instead of something to be measured.

On the comp frameworks themselves, I think the tradeoffs were spot on.

Paying on units — logos, workloads, deployed apps — is clean and easy to understand. Great for acquisition teams. But if you don’t add quality thresholds, reps will optimize for volume over value. That’s cobra farming in SaaS form.

Paying on gross billings creates alignment around customer usage and can smooth rep earnings, but quota-setting starts to feel like a black box. And if a big chunk of the book would naturally expand anyway, you’re paying reps to “own” momentum they didn’t create.

Paying on incremental run-rate is probably the most behaviorally accurate for expansion teams. You’re only rewarding net-new growth above baseline. I like that a lot in theory. But operationally, it’s harder, noisier, and much tougher to explain. The minute comp plans get too complex, trust drops. And once trust drops, motivation follows.

Then there’s the commitment model — essentially reintroducing contract value into a usage GTM. This is where I think a lot of companies over-rotate because finance loves predictability. Totally understandable in this market.

But there’s a real cost.

If you over-incent commitments, reps start pushing customers to estimate future usage too early, and suddenly the frictionless promise of consumption pricing disappears. Longer cycles, more negotiation, more shelfware risk. You get cash visibility, but maybe at the expense of velocity and customer fit.

That tradeoff matters a lot right now.

We’re in a SaaS environment where efficient growth is back in vogue, multiples still reward durable expansion, and boards are scrutinizing net retention quality more than ever. In that context, the best comp plans are the ones that balance three things:

behavioral clarity, forecastability, and customer value realization.

Miss one, and the model gets shaky.

My biggest takeaway is this:

A consumption GTM needs a compensation system that reflects the actual engine of growth. Not the old engine. Not the finance team’s idealized version. The real one.

If I were advising a seed to Series B company moving toward usage-based pricing, I’d start with a few questions before touching comp mechanics:

What behavior are we trying to create?

What growth is truly sales-driven versus product-driven?

Where does post-sales own expansion versus protection?

Can reps understand the plan in 2 minutes?

If the answer to that last one is no, I’d simplify before doing anything else.

Because the best comp plans aren’t the most elegant on a spreadsheet. They’re the ones that make the field say: I know exactly what winning looks like.

And in consumption, that definition of winning has to go far beyond closing the initial deal.