You can ship without these. But you can't scale without them. These are the skills that turn a side project into a real product.
ESLint catches bugs before they happen. Prettier makes your code consistent without thinking. Set them up once with a config file and forget about them. Your AI tool generates messy code? Prettier fixes it on save. Linting isn't about style — it's about catching === vs ==, unused variables, and unreachable code before production does.
Middleware runs before your page loads. It's how you redirect unauthenticated users, add headers, handle geolocation, and rewrite URLs. Think of it as a security guard at the door of every route.
Once you understand the request/response cycle, middleware becomes your most powerful tool for controlling app behavior without cluttering page code.
JWT tokens: stateless, stored client-side, decoded on every request. OAuth: "Sign in with Google/GitHub" — you delegate identity to a trusted provider. Know when to use which.
Know what a refresh token does. Know why you never store tokens in localStorage for sensitive apps. Auth is the one thing you absolutely cannot get wrong.
If you're copying and pasting the same button, card, or modal across files — stop. Extract it into a component that accepts props. Make it flexible but not over-engineered. A good reusable component does one thing well and works everywhere. This is the difference between a codebase that scales and one that drowns in tech debt.
Local state for UI. Global state for auth and user data. Server state for API responses. Don't put everything in Redux — most apps don't need it. React Context works for small apps. Zustand or Jotai for medium. The key: keep state as close to where it's used as possible. Prop drilling three levels deep? Time to rethink.
Hit an API 1000 times per minute and you'll get blocked. Implement rate limiting on your server. Cache responses that don't change often — user profiles, product listings, config data. Redis for server-side. stale-while-revalidate for the frontend.
Fast apps aren't fast because of faster servers — they're fast because they avoid unnecessary work.
Title tags, meta descriptions, canonical URLs, Open Graph images, structured data. If Google can't understand your page, nobody finds it. Use semantic HTML — <h1> for titles, <nav> for navigation, <main> for content. Fast load times help rankings. So does mobile-friendliness. SEO isn't magic — it's markup and common sense.
Over half your users are on phones. Design mobile-first, then scale up. Use max-width instead of fixed width. Use CSS Grid and Flexbox — not floats. Test on actual devices, not just Chrome's device toggle. A responsive site isn't one that "works on mobile" — it's one that feels native on every screen size.
Lazy load images. Code split routes. Minimize bundle size. Compress assets. Use a CDN. Measure with Lighthouse.
The biggest wins come from the simplest changes: serving optimized images saves more time than rewriting your render logic. Performance isn't premature optimization — it's respecting your users' time and bandwidth.
Main branch is sacred — never push broken code to it. Feature branches for new work. Hotfix branches for emergencies. Pull requests for code review. Learn git rebase vs git merge and when to use each. A clean git history tells the story of your project. A messy one tells the story of your chaos.
You know the skills. Now ship them faster. EmbedAI handles the AI infrastructure — RAG, search, chat — so you can focus on your product.