About
Strategic leader with over a decade of experience in developing technology and products…
Activity
2K followers
-
Jason Waldrip posted thisNew from the collective: AI gave every codebase the same poker face. Clean, tested, documented, whether the team understands it or not. The diligence question that still works isn't in the repo: can the founders debug the revenue-critical code live, and what did they deliberately not build? https://lnkd.in/gr_i-Dvb
-
Jason Waldrip posted thisA small team, and the plan is to hire three: an iOS engineer, an Android engineer, a web engineer. Three codebases, three release trains, the same login screen written three times, drifting apart by the second sprint. Or: one shared codebase, one team, a bug fixed once. At GigSmart we took two apps from zero to shipped in eight months on exactly that bet. The tax is real, when a screen has to feel genuinely native, you drop down and build that piece native. Pay for polish where the product earns it. Bank the shared velocity everywhere else. https://lnkd.in/gKcfYqA2
-
Jason Waldrip posted thisNew from the collective: measuring AI adoption by logins and prompts is Goodhart's Law with better dashboards. The instant usage is what gets graded, usage is what you get, and nothing else. What actually matters: did revenue go up, did margin improve, did your people get hours back. https://lnkd.in/gBwk-fbu
-
Jason Waldrip posted thisWe just published this at Bushido, and it names a pattern I keep running into. Coding compresses with AI because a pull request is a closed problem: the compiler and the test suite are the referee. Management doesn't compress, because a 1:1 or a postmortem isn't worth anything until the other person trusts who wrote it, and trust doesn't fit in a context window. If your team's shipping twice as fast and your meetings still eat exactly the same hours they did two years ago, this is why. https://lnkd.in/gTrPC6E4
-
Jason Waldrip posted thisNo-code is a loan. You drag four nodes onto a canvas, wire up a welcome email and a Slack ping, hit save. Ten minutes, no deploy, no PR. It fires. You move on. Eight months later a support ticket lands: new customers aren't getting the email. You open the canvas. Nobody remembers building half of it. No test failed, because there was never a test. You found out from a customer. That gap, between "it fired on Friday" and "I heard about it from a customer," is the whole problem with no-code once it stops being glue and starts being load-bearing. The speed is real. At the edge (an internal notification, a nightly sync, the thing that can fail at 3am and nobody feels it) it's a genuine gift. But nobody decides to run the business on a drag-and-drop canvas. It happens one node at a time, until the convenience becomes the only path, and you don't notice the day it crosses over. I'm cleaning up exactly this at Phoneware right now: customizations scattered across per-customer JS bundles and app backends stranded in n8n flows. The fix wasn't more flows. It was pulling the logic out of code and glue and into data, a manifest API that cascades reseller to domain to role, in one TypeScript monorepo. A customer's configuration is a value now, not a fork. Changing it is a pull request a compiler and test suite see before any customer does. There's a second bill on that loan most people miss. A fleet of agents can reason over a typed monorepo: read the manifest, follow the cascade, change a value, let CI tell it the blast radius. It cannot reason over a canvas. Wire your core logic into a drag-and-drop builder and you've hidden it from the one thing that was going to make you faster. I'm not here to trash no-code. It fits the edge. The moment a customer can feel it, or your business stops if it stops, it's not glue anymore. It's infrastructure, and infrastructure earns a repo, a test, and a diff. Full piece: https://lnkd.in/gKCgBbCs
-
Jason Waldrip shared this92, not too bad :-) https://lnkd.in/g65gbnDe
-
Jason Waldrip posted thisJust use Postgres. Two engineers. New project. Architecture already has Redis, a message queue, and Elasticsearch — before a single user signs up. Postgres does all three. Not forever. But right now, at your actual load, it does. At Brandfolder we added Go when Ruby was genuinely bottlenecking us on heavy IO. Not before. We waited until the first tool was actually failing. That's when complexity earns its place. The impressive stack isn't the right stack. The right stack fits the actual constraint — not the conference stage, not the résumé. Earn it. https://lnkd.in/g7Fy8Jju
-
Jason Waldrip posted thisPoint a task at a frontier API and you've made two decisions without noticing: rent the intelligence, hand your data to someone else's server. Sometimes that's right. Often you reached for the biggest model because it was there, not because the job needed it. Classification, extraction, routing don't need frontier reasoning — an open-weight model you run yourself does them cheaper and keeps the data in the building. Qwen and DeepSeek are closing the gap fast. Save the frontier for the problems that actually earn it. → https://lnkd.in/gXWy-mqj
-
Jason Waldrip posted thisThe deploy path is a product. It has users. It has reliability requirements. And when it breaks, it breaks everyone. If you can't ship on a Friday afternoon without sweating it, that's not a culture problem. That's a tracks problem. Nobody skips deploys because they lack courage — they skip them because the pipeline is brittle and terrifying. Fix the rails. The courage shows up on its own. CI, your release pipeline, your guardrails — that's not plumbing. That's your product. https://lnkd.in/gqx63AP4
Experience
Licenses & Certifications
Recommendations received
4 people have recommended Jason
Join now to viewOther similar profiles
Explore more posts
-
Brady Weller
Brian Lamb and his team at Promissory are building a modern platform for stacking trusts and maximizing QSBS. He answers all of the critical questions around how these trusts can be used, and who they're best suited for, on this week's episode of "QSBS, Solved". Listen: https://lnkd.in/eVjXnEKC
1 Comment -
Janardhan Korapala
There's a disconnect that shows up in almost every team we talk to. IT Directors see upgrades as: schedule it, execute it, move on. DBAs see upgrades as: test it in staging (which doesn't match production), identify every dependency that could break, build a rollback plan for the 15 things that might go wrong, coordinate with 3 other teams, execute during a window that's too short, and then monitor for 48 hours hoping nothing surfaces. Neither side is wrong. They're just seeing different parts of the same elephant. The teams that handle upgrades well aren't the ones with the best DBAs or the best IT Directors. They're the ones where both sides have the same visibility into what's happening, what's at risk, and what the fallback is. When was the last time your DBA and IT Director sat down and mapped out an upgrade end-to-end together?
1 Comment
Explore top content on LinkedIn
Find curated posts and insights for relevant topics all in one place.
View top content