SSwangnice

Software & Intelligence

Full-stack Dev

Frontend, backend, deployment, product engineering, and maintainable system design.

35 posts0 featured145 tags
Past year
Show all-time heatmap

Related Articles

All published articles in this knowledge area are collected here automatically.

Full-Stack: Zero to DepthA long-form series on the modern 2026 stack: from environment setup and frontend/backend fundamentals to the data layer, deployment, and AI-assisted development.8 posts →SaaS Security: Zero to EnterpriseAn open-ended series on securing a SaaS: tenant isolation, identity and SSO, billing and abuse, compliance and incident response — no fixed table of contents, planned one part at a time.13 posts →Rust: Zero to DepthA fixed-syllabus Rust series: ownership and borrowing, lifetimes and the type system, Cargo engineering, concurrency and async, unsafe and macros, performance work, and ecosystem choices — from the first program to thinking like a Rustacean.14 posts →

Full-Stack: Zero to Depth

A long-form series on the modern 2026 stack: from environment setup and frontend/backend fundamentals to the data layer, deployment, and AI-assisted development.

Full-Stack: Zero to Depth

Full-Stack in 2026: The Map Before the Code

Part 1 of the Zero to Depth series: what full-stack means in 2026, how the modern stack actually fits together, and what is worth learning in which order.

Full-stackTypeScriptNode.jsReactNext.jsAI Coding
Full-Stack: Zero to Depth

Choosing the Meta-Framework: Next.js 16 vs Astro in 2026

Part 4 of the Zero to Depth series: what meta-frameworks actually do, the 2026 rendering menu, Cache Components vs islands, and a decision rule that holds up.

Next.jsAstroRenderingCachingPPRIslands

SaaS Security: Zero to Enterprise

An open-ended series on securing a SaaS: tenant isolation, identity and SSO, billing and abuse, compliance and incident response — no fixed table of contents, planned one part at a time.

SaaS Security: Zero to Enterprise

Abuse: The Attack That Looks Like Growth

Part 7 of the SaaS security series: why most of your traffic isn't human, the economics of trial farming, the graduated friction ladder, detection over prevention, and why your users' stolen passwords are your roadmap item.

SaaSSecurityAbuseFraudBotsAccount Takeover
SaaS Security: Zero to Enterprise

Coding Agents: The Junior Dev With Root

Part 11 of the SaaS security series: the lethal trifecta every useful agent ships with, config files as execution vectors, MCP as the new npm, agents in CI as exfiltration channels, and the guardrails that are controls rather than instructions.

SaaSSecurityAI AgentsMCPPrompt InjectionSupply Chain
SaaS Security: Zero to Enterprise

Billing: The Endpoint Anyone Can POST To

Part 4 of the SaaS security series: webhook signature verification and replay defense, the entitlement write path, PCI DSS 4.0.1's payment-page script rules, card testing in the VAMP era, and what a merchant of record actually moves.

SaaSSecurityBillingWebhooksPCI DSSFraud
SaaS Security: Zero to Enterprise

Encryption: The Math Is Easy, the Keys Are the Job

Part 8 of the SaaS security series: envelope encryption as the only architecture that matters, per-tenant keys and crypto shredding, what BYOK and HYOK buyers actually want, and the post-quantum migration already underway.

SaaSSecurityEncryptionKMSBYOKPost-Quantum
SaaS Security: Zero to Enterprise

Incident Response: The Plan You Need at 3 A.M.

Part 6 of the SaaS security series: the disclosure clocks that start at awareness, the first-hour sequence that decides the postmortem, containment as a business decision, and why a tested IR plan is the cheapest control you own.

SaaSSecurityIncident ResponseComplianceGDPRResilience
SaaS Security: Zero to Enterprise

Privacy: The Feature That Deletes

Part 10 of the SaaS security series: the enforcement backdrop in 2026, minimization as architecture, retention that actually deletes, the DSAR as a distributed query with a deadline, and the transfer problem that owns the biggest fines.

SaaSSecurityPrivacyGDPRData RetentionCompliance
SaaS Security: Zero to Enterprise

SOC 2: The Report That Answers 'Says Who?'

Part 5 of the SaaS security series: attestation vs certification, what auditors actually sample, the observation window that can't be cram-studied, subservice providers and CUECs, and why evidence is a pipeline rather than a scramble.

SaaSSecuritySOC 2ComplianceAuditEnterprise
SaaS Security: Zero to Enterprise

The Supply Chain: Your CI Is the Most Privileged System You Own

Part 9 of the SaaS security series: the 2025–2026 npm attack wave, what provenance proves and what it can't, the consumer-side checklist that costs an afternoon, and the CI trust boundaries where the real bugs live.

SaaSSecuritySupply ChainCI/CDnpmSLSA
SaaS Security: Zero to Enterprise

The Cadence: Twelve Doors, One Habit

Part 13, the capstone of the SaaS security series: the twelve parts distilled into one map, the maturity order that is a strategy rather than a shopping list, the principles that survived every part, and the cadence that keeps controls alive.

SaaSSecurityStrategyMaturityOperationsCapstone
SaaS Security: Zero to Enterprise

Third Parties: The Stack You Can't Patch

Part 12 of the SaaS security series: the Salesloft Drift breach anatomy, the inventory nobody can produce, integrations as non-human identities, the contract layer that actually matters, and why offboarding is where risk retires.

SaaSSecurityThird-Party RiskVendorsOAuthSupply Chain
SaaS Security: Zero to Enterprise

Audit Logs: The Feature That Answers 'Prove It'

Part 3 of the SaaS security series: what belongs in an audit event, what must never be logged, the write path that can't drop events, tamper-evidence with hash chains, and why the export is the actual product.

SaaSSecurityAudit LogsComplianceSIEMArchitecture
SaaS Security: Zero to Enterprise

Identity: The Day Someone Asks 'Do You Support SSO?'

Part 2 of the SaaS security series: social login vs enterprise SSO vs SCIM, SAML 2.0 vs OIDC in procurement reality, the build-vs-buy landscape, and the controls buyers actually check.

SaaSSecuritySSOSAMLOIDCSCIMIdentity
SaaS Security: Zero to Enterprise

SaaS Security Starts with One Question: Whose Data Is This?

Part 1 of an open-ended SaaS security series: the multi-tenant mindset, three isolation models, the four rules that stop cross-tenant leaks, and the footguns that bypass them.

SaaSSecurityMulti-tenantPostgresRLSArchitecture

Rust: Zero to Depth

A fixed-syllabus Rust series: ownership and borrowing, lifetimes and the type system, Cargo engineering, concurrency and async, unsafe and macros, performance work, and ecosystem choices — from the first program to thinking like a Rustacean.

Rust: Zero to Depth

Async/Await: An Honest Teardown of State Machines, Poll, and Executors

Part 10 of the Rust: Zero to Depth series: the state machine an async fn compiles into, why a Future does nothing until polled, a hand-written Future and a toy executor, the waker's role, which bottleneck of the thread model tokio solves, and the selection rule — threads for CPU-bound work, async for I/O-bound work.

RustAsyncAwaitFutureTokioExecutors
Rust: Zero to Depth

Cargo and the Module System: Packing the Type System into a Maintainable Project

Part 8 of the Rust: Zero to Depth series: the real relationship between packages and crates, how mod declarations wire the module tree, the visibility ladder and E0603, organizing with workspaces and their shared build cache, the additive rule of feature flags, and the cargo commands you use every workday.

RustCargoModulesWorkspaceFeature FlagsTooling
Rust: Zero to Depth

Fearless Concurrency: How Data Races Become Compile Errors

Part 9 of the Rust: Zero to Depth series: how the Send and Sync marker traits make thread-safety a type-level fact, how scoped threads legally borrow stack data, the exact correspondence between Arc<Mutex<T>> and Part 6's Rc<RefCell<T>>, and the ownership philosophy behind channels — share memory by communicating.

RustConcurrencySend SyncArc MutexChannelsFearless Concurrency
Rust: Zero to Depth

Ecosystem Selection and the Voyage: From cargo new to Rustacean

Part 14 of the Rust: Zero to Depth series (the finale): the de facto standards of the starter stack, the thiserror/anyhow dividing line proven in code, a five-signal due-diligence method for reading a crate, a full look back across fourteen parts, and the road ahead for a Rustacean.

RustEcosystemCratesthiserroranyhowCareer
Rust: Zero to Depth

Enums Are State Machines: Pattern Matching and the Type System's First Payoff

Part 4 of the Rust: Zero to Depth series: enums that carry data and make illegal states unrepresentable, match and its exhaustiveness check turning refactors into a guided walk, Option as the funeral of null, and how Result with the ? operator flattens error handling from a pyramid into a straight line.

RustEnumsPattern MatchingError HandlingResult
Rust: Zero to Depth

Generics and impl Trait: One Contract, Two Directions

Part 7 of the Rust: Zero to Depth series: the full grammar of generics and trait bounds, why monomorphization is zero-cost, the asymmetry of impl Trait in argument vs return position, the static-vs-dyn dispatch trade-off, and the return-position lifetime capture the 2024 edition fixed with + use<...>.

RustGenericsimpl TraitdynMonomorphizationRust 2024
Rust: Zero to Depth

Macros: Code That Writes Code, and When to Resist Writing It

Part 12 of the Rust: Zero to Depth series: why println! can only be a macro, the pattern-matcher nature of macro_rules! declarative macros, how hygiene quarantines macro-local variables, the $crate path convention, the three procedural-macro brothers (derive / attribute / function-like) with a hand-built mini derive, and the judgment ladder for when not to use a macro.

RustMacrosmacro_rulesProcedural MacrosMetaprogramming
Rust: Zero to Depth

Performance Engineering: Measure First, Then Read the Assembly Yourself

Part 13 of the Rust: Zero to Depth series: the only loop that matters in performance work, the division of labor between micro-benchmarks and profilers, allocation as the invisible tax, measured Vec growth numbers and with_capacity, how to verify the zero-cost promise of iterators with your own eyes, and five rules for the hot path.

RustPerformanceProfilingBenchmarkingZero-Cost Abstractions
Rust: Zero to Depth

Smart Pointers: Behind Every “No,” a Clearly Priced Door

Part 6 of the Rust: Zero to Depth series: why Box is not an escape hatch but the entry ticket for recursive types, how Rc shares ownership by counting, how RefCell moves borrow checking to runtime, what each half of the classic Rc<RefCell<T>> combo solves, and the price of every trade — plus their multi-threaded relatives.

RustSmart PointersBoxRcRefCellInterior Mutability
Rust: Zero to Depth

Traits: Contracts for Shared Behavior, Not Family Trees

Part 5 of the Rust: Zero to Depth series: what a trait is, why the orphan rule protects you, how a world without inheritance organizes code through composition, what one line of derive buys you, and the six standard traits you'll deal with every day — Debug, Display, From, Clone, Drop, and Iterator.

RustTraitsCompositionStandard LibraryIdioms
Rust: Zero to Depth

unsafe: Five Powers, One Door, and a Counterintuitive Fact

Part 11 of the Rust: Zero to Depth series: the counterintuitive fact that unsafe does not disable the borrow checker, the five exact superpowers and their uses, the contract difference between raw pointers and references, how to draw a safe-abstraction boundary with SAFETY comments, and why seasoned Rustaceans write less and less unsafe.

RustunsafeFFISafe AbstractionRaw Pointers
Rust: Zero to Depth

Why Rust, Why 2026: The Map Before the First Compile

Part 1 of the Rust: Zero to Depth series: why Rust won the systems decade, where it actually runs in 2026, the ownership idea in one paragraph, the honest learning curve, and the toolchain you need before writing a line.

RustSystems ProgrammingOwnershipCargoLearning
Rust: Zero to Depth

Lifetimes: Annotations That Describe, Not Command

Part 3 of the Rust: Zero to Depth series: what a lifetime actually is, the three elision rules that write them for you, the two places you must annotate, the two meanings of 'static, and the temporary-scope fixes in the 2024 edition.

RustLifetimesBorrow CheckerElisionRust 2024
Rust: Zero to Depth

Ownership and Borrowing: The Three Rules That Are the Language

Part 2 of the Rust: Zero to Depth series: move semantics and why assignment isn't a copy, the readers-XOR-writer rule, non-lexical lifetimes, what the 2024 edition and Polonius change, and the patterns that end the fight with the borrow checker.

RustOwnershipBorrowingMemory SafetyBorrow Checker
guest@swangnice:~$█