<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title><![CDATA[CoreConcept Blog]]></title>
    <link>https://corecocept.com/blog</link>
    <description><![CDATA[Free courses and articles on Next.js, TypeScript, microservices, caching, databases, AI, and distributed systems. Learn at your own pace.]]></description>
    <language>en-US</language>
    <lastBuildDate>Fri, 03 Jul 2026 23:01:21 GMT</lastBuildDate>
    <atom:link href="https://corecocept.com/rss.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title><![CDATA[SOLID Principles in .NET: What They Mean and Why They Matter]]></title>
      <link>https://corecocept.com/blog/solid-principles-dotnet</link>
      <guid isPermaLink="true">https://corecocept.com/blog/solid-principles-dotnet</guid>
      <description><![CDATA[SOLID is five principles for writing object-oriented code that's easy to extend without breaking existing behavior. They were named by Robert Martin and have become the foundational vocabulary of software design discussions. Every developer claims to know them, but in practice most codebases violate]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>.NET</category>
      <category>Architecture</category>
      <category>SOLID</category>
      <category>Clean Code</category>
      <category>Design Patterns</category>
    </item>
    <item>
      <title><![CDATA[CI/CD Pipelines with GitHub Actions: From Commit to Production]]></title>
      <link>https://corecocept.com/blog/cicd-github-actions-deployment</link>
      <guid isPermaLink="true">https://corecocept.com/blog/cicd-github-actions-deployment</guid>
      <description><![CDATA[Manual deployments are one of the highest-risk activities in software engineering. A developer SSHes into a production server, runs commands from memory, makes a mistake, and causes an outage at 5pm on a Friday. Continuous Integration and Continuous Deployment (CI/CD) automates the path from a Git c]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>CI/CD</category>
      <category>GitHub Actions</category>
      <category>DevOps</category>
      <category>Docker</category>
      <category>Deployment</category>
    </item>
    <item>
      <title><![CDATA[TypeScript Advanced Patterns: Utility Types, Generics, and Type Guards]]></title>
      <link>https://corecocept.com/blog/typescript-advanced-patterns</link>
      <guid isPermaLink="true">https://corecocept.com/blog/typescript-advanced-patterns</guid>
      <description><![CDATA[Most TypeScript codebases use 10% of what the type system can do. Types are added to function parameters, maybe some interfaces are defined, and the rest is any or as casting. This isn't wrong — it works — but it means TypeScript is acting as a linter, not a verifier. The type system is powerful eno]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>TypeScript</category>
      <category>Web Development</category>
      <category>Type Safety</category>
      <category>Generics</category>
      <category>Patterns</category>
    </item>
    <item>
      <title><![CDATA[REST API Design Best Practices: Versioning, Pagination, and Error Handling]]></title>
      <link>https://corecocept.com/blog/rest-api-design-best-practices</link>
      <guid isPermaLink="true">https://corecocept.com/blog/rest-api-design-best-practices</guid>
      <description><![CDATA[A well-designed REST API is a contract. Clients depend on your URL structure, your error format, and your pagination scheme for months or years after you publish it. Breaking changes silently corrupt client data and cause outages. A poorly designed API that becomes popular is more painful than one t]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>REST</category>
      <category>API Design</category>
      <category>Backend</category>
      <category>HTTP</category>
      <category>Best Practices</category>
    </item>
    <item>
      <title><![CDATA[Database Indexing Explained: B-Trees, Composite Indexes, and Query Optimization]]></title>
      <link>https://corecocept.com/blog/database-indexing-explained</link>
      <guid isPermaLink="true">https://corecocept.com/blog/database-indexing-explained</guid>
      <description><![CDATA[A query that takes 4 seconds without an index takes 0.2ms with one. That's a 20,000x improvement from a single line of SQL. Indexes are the most impactful performance tool available to application developers — and the most misunderstood. Many developers add indexes reactively (when a query is alread]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Databases</category>
      <category>SQL</category>
      <category>Performance</category>
      <category>PostgreSQL</category>
      <category>Query Optimization</category>
    </item>
    <item>
      <title><![CDATA[Observability: Logs, Metrics, and Traces]]></title>
      <link>https://corecocept.com/blog/observability-logs-metrics-traces</link>
      <guid isPermaLink="true">https://corecocept.com/blog/observability-logs-metrics-traces</guid>
      <description><![CDATA[When a production system breaks at 3am, you need to answer three questions fast: what happened, how bad is it, and where is the bottleneck? Logs tell you what happened — discrete events with timestamps and context. Metrics tell you how bad — aggregated numbers like error rate, latency percentiles, a]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Observability</category>
      <category>OpenTelemetry</category>
      <category>Monitoring</category>
      <category>System Design</category>
      <category>DevOps</category>
    </item>
    <item>
      <title><![CDATA[WebSocket vs SSE vs Long Polling]]></title>
      <link>https://corecocept.com/blog/websocket-vs-sse-vs-long-polling</link>
      <guid isPermaLink="true">https://corecocept.com/blog/websocket-vs-sse-vs-long-polling</guid>
      <description><![CDATA[Real-time communication between server and client breaks the standard HTTP request-response model. When you need live updates — chat messages, stock prices, collaborative editing, or push notifications — you choose between three patterns: WebSockets for bidirectional communication, Server-Sent Event]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>WebSocket</category>
      <category>SSE</category>
      <category>Real-time</category>
      <category>HTTP</category>
      <category>API</category>
    </item>
    <item>
      <title><![CDATA[Horizontal vs Vertical Scaling]]></title>
      <link>https://corecocept.com/blog/horizontal-vs-vertical-scaling</link>
      <guid isPermaLink="true">https://corecocept.com/blog/horizontal-vs-vertical-scaling</guid>
      <description><![CDATA[Scaling is how a system handles more users, data, or traffic. Vertical scaling (scale up) means giving your existing server more resources — bigger CPU, more RAM, faster disk. Horizontal scaling (scale out) means adding more servers and distributing load across them. Every production system eventual]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Scaling</category>
      <category>System Design</category>
      <category>Load Balancing</category>
      <category>Performance</category>
    </item>
    <item>
      <title><![CDATA[Event Sourcing vs CQRS]]></title>
      <link>https://corecocept.com/blog/event-sourcing-vs-cqrs</link>
      <guid isPermaLink="true">https://corecocept.com/blog/event-sourcing-vs-cqrs</guid>
      <description><![CDATA[Event Sourcing and CQRS are two patterns that often appear together in microservices and domain-driven design — but they solve different problems. Event Sourcing stores state as a sequence of domain events instead of updating rows in place — giving you a complete audit trail and the ability to rebui]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Event Sourcing</category>
      <category>CQRS</category>
      <category>Microservices</category>
      <category>Architecture</category>
      <category>DDD</category>
    </item>
    <item>
      <title><![CDATA[Caching Strategies: Redis, CDN, and Multi-Level Caches]]></title>
      <link>https://corecocept.com/blog/caching-strategies-redis-cdn</link>
      <guid isPermaLink="true">https://corecocept.com/blog/caching-strategies-redis-cdn</guid>
      <description><![CDATA[Caching is the fastest way to scale a system without changing your database or adding servers. Done right, it cuts database load by 90%, drops response times from 200ms to 2ms, and absorbs traffic spikes that would otherwise topple your stack. Done wrong, it serves stale data, hides real bugs, and a]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Caching</category>
      <category>Redis</category>
      <category>CDN</category>
      <category>Performance</category>
      <category>System Design</category>
    </item>
    <item>
      <title><![CDATA[JWT Deep Dive: What's Inside a Token and How to Validate It Safely]]></title>
      <link>https://corecocept.com/blog/jwt-deep-dive-validation-security</link>
      <guid isPermaLink="true">https://corecocept.com/blog/jwt-deep-dive-validation-security</guid>
      <description><![CDATA[JSON Web Tokens are everywhere — issued by every OAuth 2.0 provider, sent in every Authorization: Bearer header, decoded by every modern API. But most developers treat them as black boxes: 'it's three Base64 strings separated by dots, it works, move on.' That vagueness is how security vulnerabilitie]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>JWT</category>
      <category>Security</category>
      <category>Authentication</category>
      <category>API</category>
      <category>.NET</category>
    </item>
    <item>
      <title><![CDATA[Event-Driven Architecture: Choreography, Orchestration, and Event Sourcing]]></title>
      <link>https://corecocept.com/blog/event-driven-architecture-patterns</link>
      <guid isPermaLink="true">https://corecocept.com/blog/event-driven-architecture-patterns</guid>
      <description><![CDATA[Synchronous microservices create invisible chains: when the payment service is slow, the order service is slow, and when the email service is down, orders fail. Event-driven architecture breaks these chains by letting services communicate through events instead of direct calls — a service publishes ]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Event-Driven</category>
      <category>Microservices</category>
      <category>Architecture</category>
      <category>Kafka</category>
      <category>Event Sourcing</category>
    </item>
    <item>
      <title><![CDATA[Clean Architecture in .NET: Layers, CQRS, and the Dependency Rule]]></title>
      <link>https://corecocept.com/blog/clean-architecture-dotnet</link>
      <guid isPermaLink="true">https://corecocept.com/blog/clean-architecture-dotnet</guid>
      <description><![CDATA[Most .NET projects start clean and become entangled within six months. Controllers call repositories that call other services that reach back into controllers. Business logic lives in HTTP action methods. Tests require spinning up a database. A new developer can't tell where to put new code without ]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>.NET</category>
      <category>Architecture</category>
      <category>Clean Architecture</category>
      <category>CQRS</category>
      <category>DDD</category>
    </item>
    <item>
      <title><![CDATA[CAP Theorem Explained]]></title>
      <link>https://corecocept.com/blog/cap-theorem-explained</link>
      <guid isPermaLink="true">https://corecocept.com/blog/cap-theorem-explained</guid>
      <description><![CDATA[The CAP theorem states that a distributed system can guarantee at most two of three properties: Consistency (every read returns the latest write), Availability (every request gets a response), and Partition tolerance (the system works despite network failures between nodes). When a network partition]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>CAP Theorem</category>
      <category>System Design</category>
      <category>Distributed Systems</category>
      <category>Databases</category>
    </item>
    <item>
      <title><![CDATA[SQL vs NoSQL: A Developer's Comparison]]></title>
      <link>https://corecocept.com/blog/sql-vs-nosql-comparison</link>
      <guid isPermaLink="true">https://corecocept.com/blog/sql-vs-nosql-comparison</guid>
      <description><![CDATA[SQL and NoSQL are not opposites — they solve different data problems. SQL databases store data in normalized tables with strict schemas, ACID transactions, and powerful JOIN queries. NoSQL databases trade some of that rigidity for horizontal scalability, flexible schemas, and data models tuned to sp]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>SQL</category>
      <category>NoSQL</category>
      <category>Database</category>
      <category>PostgreSQL</category>
      <category>MongoDB</category>
    </item>
    <item>
      <title><![CDATA[Prompt Engineering for Developers]]></title>
      <link>https://corecocept.com/blog/prompt-engineering-for-developers</link>
      <guid isPermaLink="true">https://corecocept.com/blog/prompt-engineering-for-developers</guid>
      <description><![CDATA[Prompt engineering is the practice of designing inputs to large language models so they produce reliable, useful outputs. Unlike traditional programming where logic is explicit, LLMs respond to natural language instructions — and small changes in phrasing, structure, or examples dramatically affect ]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Prompt Engineering</category>
      <category>AI</category>
      <category>LLM</category>
      <category>GPT</category>
      <category>Development</category>
    </item>
    <item>
      <title><![CDATA[Docker vs Kubernetes]]></title>
      <link>https://corecocept.com/blog/docker-vs-kubernetes</link>
      <guid isPermaLink="true">https://corecocept.com/blog/docker-vs-kubernetes</guid>
      <description><![CDATA[Docker and Kubernetes are often mentioned together, but they solve different problems. Docker packages your application and its dependencies into a portable container image that runs consistently on any machine. Kubernetes orchestrates those containers across a cluster — scheduling, scaling, healing]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Docker</category>
      <category>Kubernetes</category>
      <category>DevOps</category>
      <category>Containers</category>
      <category>Cloud</category>
    </item>
    <item>
      <title><![CDATA[Monolith vs Microservices vs Modular Monolith]]></title>
      <link>https://corecocept.com/blog/monolith-vs-microservices-vs-modular-monolith</link>
      <guid isPermaLink="true">https://corecocept.com/blog/monolith-vs-microservices-vs-modular-monolith</guid>
      <description><![CDATA[Every new project faces the same question: one big application or many small services? The answer is rarely binary. A monolith ships fast and stays simple until team size and traffic grow. Microservices give team autonomy and independent scaling but introduce network failures, distributed tracing, a]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Architecture</category>
      <category>Microservices</category>
      <category>Monolith</category>
      <category>System Design</category>
    </item>
    <item>
      <title><![CDATA[JWT vs Session vs OAuth 2.0]]></title>
      <link>https://corecocept.com/blog/jwt-vs-session-vs-oauth</link>
      <guid isPermaLink="true">https://corecocept.com/blog/jwt-vs-session-vs-oauth</guid>
      <description><![CDATA[Authentication in modern apps spans three distinct models. Sessions store user state on the server and send a session ID in a cookie — simple and revocable, but requiring sticky sessions or a shared store at scale. JWTs embed claims in a signed token the client sends on every request — stateless and]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Authentication</category>
      <category>JWT</category>
      <category>OAuth</category>
      <category>Security</category>
      <category>API</category>
    </item>
    <item>
      <title><![CDATA[Load Balancing: Layer 4 vs Layer 7]]></title>
      <link>https://corecocept.com/blog/load-balancing-l4-vs-l7</link>
      <guid isPermaLink="true">https://corecocept.com/blog/load-balancing-l4-vs-l7</guid>
      <description><![CDATA[Load balancers distribute incoming traffic across multiple servers so no single machine becomes a bottleneck. But not all load balancers work the same way. Layer 4 (transport) balancers route by IP address and port — fast and protocol-agnostic. Layer 7 (application) balancers inspect HTTP headers, U]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Load Balancing</category>
      <category>System Design</category>
      <category>Networking</category>
      <category>Scalability</category>
    </item>
    <item>
      <title><![CDATA[Rate Limiting: Token Bucket vs Sliding Window]]></title>
      <link>https://corecocept.com/blog/rate-limiting-algorithms</link>
      <guid isPermaLink="true">https://corecocept.com/blog/rate-limiting-algorithms</guid>
      <description><![CDATA[Every public API needs rate limiting — to prevent abuse, protect downstream services, and ensure fair usage across tenants. Without it, one aggressive client can overwhelm your database while others get timeouts. The two most common algorithms are the token bucket and the sliding window log — each w]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Rate Limiting</category>
      <category>API</category>
      <category>Performance</category>
      <category>System Design</category>
    </item>
    <item>
      <title><![CDATA[Kafka vs RabbitMQ vs Amazon SQS]]></title>
      <link>https://corecocept.com/blog/kafka-vs-rabbitmq-vs-sqs</link>
      <guid isPermaLink="true">https://corecocept.com/blog/kafka-vs-rabbitmq-vs-sqs</guid>
      <description><![CDATA[Asynchronous messaging decouples services in time — producers send messages without waiting for consumers. But not all message brokers work the same way. Apache Kafka is a distributed event log built for high-throughput streaming and replay. RabbitMQ is a flexible message broker with rich routing vi]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>Kafka</category>
      <category>RabbitMQ</category>
      <category>SQS</category>
      <category>Messaging</category>
      <category>Microservices</category>
    </item>
    <item>
      <title><![CDATA[API Styles: REST vs GraphQL vs gRPC]]></title>
      <link>https://corecocept.com/blog/graphql-vs-rest-vs-grpc</link>
      <guid isPermaLink="true">https://corecocept.com/blog/graphql-vs-rest-vs-grpc</guid>
      <description><![CDATA[Modern systems rarely pick one API style for everything. REST uses HTTP and JSON — simple, cache-friendly, and the default for public web APIs. GraphQL exposes a single endpoint where clients request only the fields they need — ideal for complex frontends with varied data shapes. gRPC runs on HTTP/2]]></description>
      <pubDate>Sat, 04 Jul 2026 00:00:00 GMT</pubDate>
      <category>GraphQL</category>
      <category>REST</category>
      <category>gRPC</category>
      <category>API</category>
      <category>Architecture</category>
    </item>
    <item>
      <title><![CDATA[Communication Protocols Between Services]]></title>
      <link>https://corecocept.com/blog/communication-protocols-between-services</link>
      <guid isPermaLink="true">https://corecocept.com/blog/communication-protocols-between-services</guid>
      <description><![CDATA[Modern backends rarely speak one language. Clients hit REST endpoints through an API Gateway. Mobile apps send GraphQL queries to fetch exactly the fields they need. Dashboards maintain WebSocket connections for live updates. External partners push events via webhooks. Inside the backend, services c]]></description>
      <pubDate>Thu, 02 Jul 2026 00:00:00 GMT</pubDate>
      <category>Microservices</category>
      <category>REST</category>
      <category>GraphQL</category>
      <category>gRPC</category>
      <category>WebSocket</category>
      <category>SOAP</category>
      <category>Architecture</category>
    </item>
    <item>
      <title><![CDATA[REST API Authentication Methods]]></title>
      <link>https://corecocept.com/blog/rest-api-authentication-methods</link>
      <guid isPermaLink="true">https://corecocept.com/blog/rest-api-authentication-methods</guid>
      <description><![CDATA[Every REST API needs a way to verify who is calling it and what they are allowed to do. The method you choose shapes your security posture, client experience, and operational complexity. Basic Auth sends credentials on every request. Token Auth issues a signed credential after login. OAuth delegates]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>REST</category>
      <category>API</category>
      <category>Security</category>
      <category>OAuth</category>
      <category>Authentication</category>
    </item>
    <item>
      <title><![CDATA[Classic RAG vs Graph RAG vs Agentic RAG]]></title>
      <link>https://corecocept.com/blog/classic-rag-vs-graph-rag-vs-agentic-rag</link>
      <guid isPermaLink="true">https://corecocept.com/blog/classic-rag-vs-graph-rag-vs-agentic-rag</guid>
      <description><![CDATA[Retrieval-Augmented Generation (RAG) grounds LLM answers in real data instead of model memory. But not all RAG is the same. Classic RAG retrieves text chunks from a vector database. Graph RAG adds relationship-aware context from knowledge graphs. Agentic RAG introduces reasoning agents that plan, ca]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>RAG</category>
      <category>LLM</category>
      <category>AI</category>
      <category>Knowledge Graph</category>
      <category>Agents</category>
    </item>
    <item>
      <title><![CDATA[How to Choose the Right Database]]></title>
      <link>https://corecocept.com/blog/how-to-choose-database</link>
      <guid isPermaLink="true">https://corecocept.com/blog/how-to-choose-database</guid>
      <description><![CDATA[Picking a database is not about finding the fastest engine — it is about matching storage to the shape of your data. Start with one question: is your data structured, unstructured, or semi-structured? That single decision narrows the field from hundreds of options to a handful of realistic candidate]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>Databases</category>
      <category>Architecture</category>
      <category>AWS</category>
      <category>Azure</category>
      <category>GCP</category>
    </item>
    <item>
      <title><![CDATA[Microservices Design Patterns]]></title>
      <link>https://corecocept.com/blog/microservices-design-patterns</link>
      <guid isPermaLink="true">https://corecocept.com/blog/microservices-design-patterns</guid>
      <description><![CDATA[Microservices give teams independence — but independence without patterns leads to chaos. Six design patterns solve the most common problems: how clients reach services, how services find each other, how reads and writes scale, how UIs get tailored APIs, how systems communicate asynchronously, and h]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>Microservices</category>
      <category>Architecture</category>
      <category>API</category>
      <category>Distributed Systems</category>
    </item>
    <item>
      <title><![CDATA[Core Layers to Master Agentic AI]]></title>
      <link>https://corecocept.com/blog/core-layers-master-agentic-ai</link>
      <guid isPermaLink="true">https://corecocept.com/blog/core-layers-master-agentic-ai</guid>
      <description><![CDATA[Flashy demos are easy. Production agentic AI is not. In 2026, building agents that truly think, act, and improve on their own means mastering nine interconnected layers — from strategy and perception to deployment and observability. Skip one layer and the whole system breaks. This guide walks throug]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>Agentic AI</category>
      <category>Architecture</category>
      <category>LLM</category>
      <category>Agents</category>
      <category>MLOps</category>
    </item>
    <item>
      <title><![CDATA[.NET Before vs After the AI Era]]></title>
      <link>https://corecocept.com/blog/dotnet-before-vs-after-ai-era</link>
      <guid isPermaLink="true">https://corecocept.com/blog/dotnet-before-vs-after-ai-era</guid>
      <description><![CDATA[Artificial intelligence is not here to replace .NET developers. It is here to extend what they can build. The fundamentals you already know — services, APIs, data access, validation — still matter. What changes is how you compose them. Instead of shipping systems that only move data, you design syst]]></description>
      <pubDate>Wed, 01 Jul 2026 00:00:00 GMT</pubDate>
      <category>.NET</category>
      <category>AI</category>
      <category>Architecture</category>
      <category>Agents</category>
      <category>MCP</category>
    </item>
  </channel>
</rss>