SolaRise - technologies behind our startup

1. Architecture
2. Artificial intelligence
3. Design
4. Our Mission

Architecture

In order to ensure the scalability of our software and support a large number of users in the future, we decided to harness the power of the cloud, specifically AWS Amazon Web Services, to implement our software solution.

Developing software in the cloud offers numerous benefits, such as organizing code into independent microservices, adopting serverless architecture for easier server management, and initial cost savings compared to traditional monolithic infrastructure. However, the most significant advantage for us is the rapid development of software.

For startups, fast development and adaptation to the market are key to success, which is why the cloud is in our oppinion an excellent environment for the development of all software startups.

If we need to add new functionality to our software, all we need to do is deploy a new Lambda function, write the required logic, and it's ready.

The endpoint is set up to respond to user requests, and that's it. This approach allows us to pivot easily, meaning we can adapt to market demands and user requirements, focusing on creating software that truly solves our clients problems, rather than spending most of our time maintaining and debugging complex monolithic code.

If the concept of the cloud is new to you, don't worry, it's not as complicated as it may seem. There are many different offerings and so-called AWS services, and I genuinely believe that it might appear intimidating at first, just as it did to me. In reality, you only need to grasp a few basic concepts, and you can explore the rest as needed.

The primary computing unit, the entity that executes your code in the cloud, is called Lambda. It's the core serverless service, which means you don't have to manage the server on which your code runs – pretty cool, right?

Furthermore, if you require additional functionality, AWS likely has an additional service that can assist you with that.

For instance, if you're dealing with authentication and user management, you can utilize AWS Cognito. If you need a NoSQL database, DynamoDB is available for data persistence, and so on. However, these are all optional services; use them only when you need them. Additionally, almost all of these services are serverless, so you won't have to worry much about server maintenance once you've learned how the service works and what features it offers – connecting to it is quite straightforward.

• AWS Lambda
• DynamoDB
• Cognito
• S3 Bucket
• Docker Container with ECR
• Amazon Event Bridg
• ApiGateway
• IAM
• CloudWatch

Now that we've explained where our code lives, let's take a closer look at how it works.

Artificial intelligence

From the very beginning, our vision was to help businesses offer their services in innovative ways and make a larger number of customers satisfied. To achieve this, we set an ambitious goal: to provide users with the easiest possible experience when using our software.

Since this is a broad and somewhat undefined goal, we'll know we've achieved it when we only require users to perform a minimal number of actions, while the rest is handled magically by us. This is often the case with good software – you don't even notice it; it simply helps you complete your tasks effortlessly without drawing too much attention to itself. On the flip side, this means more work for developers, in this case, us. 😉

One of the technologies that enables this "magic," as I like to call it, is artificial intelligence, or AI. It can perform complex tasks for computers relatively easily and make it easier for users to accomplish their goals. Of course, it is not all sunshine and rainbows, and the only drawback of artificial intelligence is the need for a large amount of data to train it, in our case, satellite images...

We didn't let that demotivate us and started exploring our options. Naturally, we dove into what we do best – writing code.

So, we decided to create our own dataset. We wrote a short Python script that calls the Google Static Maps API for a given latitude and longitude and saves the image in a local folder called images.s One for loop, some random.random(), and bam, 10 minutes later, we had our dataset.

Our next task was to annotate these images, in other words, to show artificial intelligence what to look for in the images, specifically, what constitutes a roof and what doesn't. For this task, we used a product from another really cool startup called Roboflow https://roboflow.com/. Roboflow is truly amazing, and if you're interested in the world of artificial intelligence, be sure to check out their website. Once we had annotated images, we moved on to the next step: training the model.

This part represents our trade secret and sets us apart from the competition in the market, so I can't go into implementation details. However, when the model finished training, we had a .pth file ready for deployment on Docker to perform measurements and predictions.

• An artificial intelligence model that can identify roofs based on satellite images
• Lambda function that can find a user's latitude and longitude based on their address and request satellite images from the Google API

All the user needs to do is enter the address of the object they want to install solar panels on, and before their eyes, this little software engine diligently works and provides a personalized offer and measurements tailored specifically to their roof.

Oh, and in the latest version of our software, users don't even have to enter their address; based on their location, we can do it for them.

So, more or less, our software enables users to get a detailed roof measurement, a solar panel installation plan, and a detailed analysis and electricity production prediction, all with just a click of a button, and it's ready by the time you say SolaRise.

Design

So, we need a way to present this in the most appealing manner to users and provide them with the simplest possible interface to interact with our little magical machinery.

The task of designing our web application was entrusted to our colleague and SolaRise team member, Tina. She settled into her special thinking chair, rolled up her sleeves, opened Figma, and got to work on the design.

You can check out the result of her work at this link: SolaRise Figma Design

Once we have the design, the next step is to translate it into code. We connect our web application to AWS Lambdas via API Gateway and secure a domain.

For now, our application is hosted on Vercel under the domain https://solarise.vercel.app/, so if you want to measure your roof, feel free to try our solution. During the beta version, all our services are completely free, so make the most of it while you can.

Design is something that constantly evolves and changes.

So there's a good chance that if you're reading this blog a year after it was written, our SolaRise design will look different.

But that's entirely normal, and it shouldn't scare you away from starting something of your own. It's just a child's play, and once you learn the rules, it's a lot of fun to play.

Our mission

The goal of the SolaRise project is to create a SaaS solution that companies involved in solar panel installation worldwide can use to provide their customers with the best possible solar panel purchasing experience.

It's an undeniable fact that the solar panel market is on the rise, and everything is gradually shifting towards renewable energy sources. If we can be even a small part of this fantastic global transformation, count us in.

This is the technical side of our SolaRise startup story. If you're interested in other topics related to solar energy and startup development, check out our other blog posts.

We hope we've piqued your interest, and you like the startup we're developing. If you've made it to this part of the reading, congratulations – it means a lot to us, and we hope you've enjoyed it.

Until next time, have a great day!

Uroš Poček and the SolaRise Team