Welcome

 Hi. My name is Alex and I've been developing software since the turn of the century.  My goal with this blog is to share the steps that go into building a production quality full stack application.  I am going to start with a simple proof of concept and iterate on it. 

The application we will be building together is intended to tell users information about local landmarks while they are walking or driving around.  I have decided to call it autotoor as that was the most descriptive available domain I could find. 

Some things I hope to go through in future posts:

  • Defining the MVP (Minimum Viable Product)
  • Creating an initial app that we can run locally
  • Using Expo to test a mobile app on a phone
  • Deploying the backend to a cloud provider
  • Building a test build of the mobile app to run on a phone
  • Defining the infrastructure as code
  • Automating the build pipeline
  • Publishing the mobile app to app stores

Some technologies I plan to use along the way:

  • Node.js
  • NestJS
  • React Native
  • pnpm
  • terraform
  • Expo
  • github
  • Google Cloud

Lets get started!

Comments

New comments are not allowed.

Popular posts from this blog

Node.js Microservice with NestJS: Part 3 - NestJS Dependency Injection

An Introduction to Dependency Injection in NestJS NestJS is a powerful framework for building efficient, reliable, and scalable server-side applications. One of the core concepts in NestJS is Dependency Injection (DI) , which is built on the Inversion of Control (IoC) design pattern. In this third installment on building a microservice using  NestJS , we'll explore what dependency injection is, how it's implemented in NestJS , and why it's crucial for building maintainable applications. We'll also provide practical examples  of how we use it in our tour-service application to illustrate these concepts and break down important topics like decorators, constructors, modules, application context, and services. For more details about the service we are building and what we have done so far, check out the following posts: Node.js Microservice with NestJS: Part 1 - Service Overview  - An overview of the microservice we will be building Node.js Microservice with NestJS: Part ...
Read more

REST APIs with Controllers - Node.js Microservice with NestJS: Part 4

Building REST APIs with Controllers in NestJS NestJS is a progressive Node.js framework that builds on top of Express and uses TypeScript , making it a fantastic choice for developers seeking a structured and scalable approach to building backend applications. In this fourth installment of the series of posts on building a Node.js microservice with NestJS , we'll explore how NestJS helps developers create declarative REST APIs using controllers, along with powerful features like decorators, Data Transfer Objects (DTOs) , validation, and type transformation. If you're familiar with JAX-RS in Java, you'll notice a similar approach to structuring APIs. For more details about the service we are building and what we have done so far, check out some of the prior posts on the topic: Node.js Microservice with NestJS: Part 1 - Service Overview  - An overview of the microservice we will be building Node.js Microservice with NestJS: Part 2 - Using the NestJS CLI  - Provisioning o...
Read more

Constructor-Based vs Property-Based Dependency Injection in NestJS - Which is Better?

Image
Constructor-Based vs Property-Based Dependency Injection in NestJS - Which is Better? Using constructor-based injection is generally considered better than property-based injection in NestJS (and in many other frameworks) for several key reasons.  Lets look at a few reasons why and some scenarios where  property-based injection  may be more appropriate. Immutability and Readability Constructor-based injection ensures that dependencies are provided at the time of object creation, making them immutable . This means that the dependencies cannot be reassigned after the object is instantiated. With property-based injection , dependencies are injected later, making them mutable. This can lead to side effects if the dependencies are modified during the object's lifetime. Constructor-based injection makes it clear what dependencies the class needs at the time of instantiation, improving code readability. Example: private readonly landmarkService : LandmarkService ; constructo...
Read more