In this Era of AI, I often find myself reflecting on the software engineering field. I’ve observed several emerging patterns among new software engineers. Although i’m still a junior, I definitely see myself as part of that group.

New coming engineers are heavily relying on AI tools; however, they haven’t spent enough time building things that would give them the experience and knowledge needed to use those tools with real confidence. I’m referring to the core fundamentals of software engineering not frameworks or technologies that shift every few months.

I’m not sure about this take,, but I’ve read and listened to many accomplished software engineers in the industry, and the common theme among them is their focus on the fundamentals and the basics.

Everything becomes easier afterward not too easy, but you get the idea. Things become much clearer, and the decisions you make start to make more sense.

I found a Youtube playlist with same title as this blog post, https://youtube.com/playlist?list=PLui3EUkuMTPgZcV0QhQrOcwMPcBCcd_Q1&si=3WehL1sB2bNvXb2x, and it inspired me to start this series.

I originally learned about the idea of first principles thinking from Elon Musk, who describes it as his core approach to problem-solving (if you are curious to learn more about it https://jamesclear.com/first-principles) . But what exactly is first-principles thinking and how does it connect to software software engineering or any engineering discipline?

Thinking in first principles is about breaking a problem or subject into its components and digging deeper until you reach the root of it. from there, you can build your understanding the bottom up. Instead of thinking by analogy, you challenge every assumption and question each layer as you go. This approach leads to clearer insights into the problem and enables you to develop more solid and innovative solutions.

Connecting this idea to software engineering, it’s impossible to know every technology, framework, library, or platform. However everything built since the early days of computers and the internet traces back to a set of core functional concepts — our first principles.

Those who think in first principles can spot gaps, rethink assumptions, and ultimately create new and innovative technologies.

If I look at backend or system engineering through this lens, every application ultimately relies on a set of core principles that everything else built upon.

From the HTTP protocol and request handling to the bussiness logic layer and the database, every part of a backend system traces back to these fundamentals.

To keep things brief, I’m planning to launch a blog series where I explore the first principles of backend engineering. Here are the topics I’ll be covering in the series:

  • HTTP protocol
  • Routing
  • Serialisation and Deserialisation
  • Authentication and Authorisation
  • Validation and transformation
  • Middlewares
  • Request context
  • Handlers, controllers and services
  • CRUD Operations
  • RESTful architecture and best practices
  • Databases
  • Business logic layer (BLL)
  • Caching
  • Transactional emails
  • Task queuing and scheduling
  • Elasticsearch
  • Error handling
  • Config management
  • Logging, monitoring and observability
  • Graceful shutdown
  • Security
  • Scaling and performance
  • Concurrency and parallelism
  • Object storage and large files
  • Real-time backend systems
  • Testing and code quality
  • 12 factor app
  • OpenAPI standards
  • Webhooks
  • Deployment and Automation (aka) Devops

I’m planning to write an article that breaks down each principle in a clear, accessible way, along with a hands-on project that lets you apply each concept to a real problem.

I’m genuinely excited to begin this series, and I hope I’ll stay committed all the way through.

See you in the first First Principle!!