Yeah, it might sound clickbaity, but think about it for a second. For as long as most of us can remember, developers have been haunted by an age-old constraint: fast, cheap, or good. Pick two.

We repeated it like gospel. We built project timelines around it. We gave it to stakeholders as the excuse for late nights and budget overruns.

But something’s changed. The game has shifted.

And that myth? It’s officially dead.

Let me show you why.

The "Pick Two" Rule That Ruled Us All

You’ve heard it a thousand times:

Want it fast and cheap? It won't be good.
Want it good and fast? Open your wallet.
Want it good and cheap? See you in a year.

For decades, this wasn't just a saying. It was reality. A law of nature in software development.

Photo by Karola G

But like all laws, it only lasts until someone rewrites the rules.

Enter: Vibe Coding.

Rewind to 2015: Building Was a Battle

Imagine you're a solo founder in 2015. You've got a spark of an idea - a collaborative app, maybe a slick dashboard, maybe a tool to bring people together.

You're dreaming big. But to make it real? That dream has to pass through a minefield of core points you need to fiugre out, design, configure and execute:

• Backend logic
• Authentication
• iOS and Android frontends
• Admin panels
• Payments
• Real-time sync

You hit Upwork. You hire freelancers in different time zones. You chase deadlines, quality slips, and you lose sleep over merge conflicts.

After weeks,sometimes months, you've spent thousands of dollars. And the result? A barely functional MVP that kind of works... until it doesn't.

You didn’t fail because your idea wasn’t good. You failed because building good software was just that hard and the system was broken.

Fast-forward to Now: Welcome to Vibe Coding

It’s the end of 2025. Same idea. Same ambition. But this time, you open your LLM interface and:

• Instead of managing people, you’re managing agents.
• Instead of writing boilerplate, you’re designing workflows.
• Instead of chaos, you’ve got orchestration.
  

Photo by Darlene Alderson

Then you just say something like:

"I want to build a collaborative note-taking app. Split it into phases. Backend on SashiDo, frontend in React, mobile via Capacitor. Postgres for data. Auth, tests, SDKs, and a CLI tool, too."

No cold emails. No flaky devs. No boilerplate from scratch. Just like that, your software pipeline activates.

Not just code. A process.

It doesn’t feel like you’re building an app. It feels like you’re assembling a machine that builds apps.

What Actually Changed?

Let’s get real: this isn’t just about AI writing code faster.

This is about how you build.

Old-school development was linear. You moved from PM to dev to QA to deploy like parts on a conveyor belt. And every handoff came with friction.

With Vibe Coding, you build workflows instead of writing tickets. You split your app into smart, orchestrated pieces. Each one is executed by a specialized agent, designed to work autonomously but in sync.

Suddenly, you're not managing chaos. You're designing harmony.

Your New Workflow Might Look Like This:

Let’s say you’re building that same note-taking app. Here’s how your workflow might run:

1. Plan the Architecture

Not just “build a feature” - you split it into micro-projects:

• Backend logic
• Frontend rendering
• SDKs
• CLI tools
• API docs

Each is treated as its own mini-project, with clear boundaries and expectations.

2. Use Specialized Agents

Assign Different Specialized Agents to handle seprately:

• A planning agent to scope work
• Implementation agents to code it
• Testing agents to validate it
• Review agents to sanity check it(in fresh context, to avoid bias)

Each one works in parallel— no waiting for the next.

Photo by Eric Krull on Unsplash

3. Run Async

Your frontend and backend are built in parallel. At the same time - test agent runs separately and docs are auto-generated while code is reviewed.

4. Review Like a Lead Engineer

You're not just hoping it works. You verify:

• Test coverage?
• Edge cases?
• Compliance with best practices?**

You ask agents to simulate load. To suggest improvements. To raise flags.

And just like that, you’re not coding at hyperspeed. You’re designing systems at scale.

Why This Isn’t Just “Better Prompting”

Let’s be clear: this isn’t about writing better prompts. This is about building intelligent workflows.

Because once you do, the cost drops. The speed jumps. And yes, the quality increases.

Your value as a developer isn’t how fast you type anymore. It’s how well you:

• Architect workflows
• Embed best practices
• Run everything asynchronously
• Decoupling tasks
• Testing in isolation
• Running async
• Iterate intelligently

You’re not cutting corners. You’re cutting friction.

Photo by cottonbro studio

From Complexity to Clarity

In the old world, planning meant whiteboards, spreadsheets, and days of meetings. Now? One well-structured request to a planning agent.

Dev used to mean line-by-line implementation. Now? Your intent is scaffolded in seconds.

Testing? Used to be late-stage and error-prone. Now it’s continuous and AI-driven.

Thousands of dollars in dev hours turnes into $5–$50 per workflow cycle.

Speed of development turns from weeks or months to hours or days.

And all that rework? Gone.

Everything flows in sync. Reviewers check code without context bias. Documentation is generated in real time. Deployments happen on demand.

Photo by Joylynn Goh on Unsplash

But Wait - Is the Code Actually Good?

Not always. But guess what?

Most human-written code isn't that good either.

What matters is that Vibe Coding gives you the framework to:

• Bake in quality from the start
• Enforce structure and conventions
• Test continuously, not just at the end
• Version and rollback with clear checkpoints

Yes, you still need understadning of how things works. You need to know what “good” looks like.
But with the right workflow, you can enforce good even if you’re not a senior engineer (yet).

Why This Is the Golden Era for Indie Builders

Let’s be brutally honest. The real bottleneck in shipping ideas has never been the idea itself. It’s the process.

Most indie projects die in the gap between version 0.1 and version 1.0.

Vibe Coding closes that gap. You no longer need a full dev team. You don’t need $50K in pre-seed funding. You don’t need six months of sleepless dev nights.

You need:

• A clear idea
• A smart workflow
• A hosting environment like SashiDo to deploy & host it all

That’s it.

You can launch. You can scale. You can build a business in fraction of the time and costs compared to old times.

Photo by Tima Miroshnichenko

One Last Thought

You don’t need to be the most senior engineer in the room anymore. But you do need to be the one with the best workflow. Because in this new era - workflow eats code for breakfast.

Ready to Build Smarter?

Launch your next idea with Vibe Coding workflows and deploy it on SashiDo.

• Fully managed backend
• Static hosting for your frontend
• API-ready out of the box
• Scales with your business

🚀 Deploy your app with SashiDo in minutes.
Start your Free Trial Now.
And here is a quick Getting Started Guide for a smooth take off.

Happy Coding!

Let’s be real, writing rules manually for your AI assistant in 2025 is starting to feel a lot like coding without version control in 2010.

Still doing it? You’re not alone.
Still doing it manually? There's a better way.

If you're working with Cursor(or planning to) and your SashiDo-powered backend or fullstack app, this guide will walk you through how to make your Cursor rules evolve automatically based on how your codebase grows.

Yes, you read that right - your codebase can start teaching itself! And it only takes one file to unlock that capability. Let me show you how.

Build a Self-Improving AI Codebase with Cursor

You might already know Cursor lets you define .mdc rules—markdown-based config files that guide your AI assistant. But one rule takes things to another level: the self-improvement rule.

Photo by Tara Winstead

This is how you create a feedback loop that:

• Helps Cursor learn from your patterns
• Prevents repeating the same prompts
• Boosts your dev velocity on autopilot

Let’s walk through the steps together.

Step 1:Define the Foundational Rules

Create cursor-rules.mdc file to teach Cursor how to process, format, and locate other rules in your project. Without it, Cursor is essentially guessing. With it, you're giving it a playbook of your structure and training it to follow it exactly.

File: .cursor/rules/cursor-rules.mdc

Tip: Keep examples relevant and up to date.

Step 2: Create the Self-Evolving Brain

Once the foundational rules are in place, it’s time to add a self-improvement.mdc file to set up the feedback loop. These rules tells Cursor to analyze your codebase over time, learn from recurring patterns, and recommend or evolve new rules.

Photo by ThisIsEngineering

File: .cursor/rules/self-improvement.mdc

Make Rule Maintenance a Habit

Rules are not a set-and-forget operation. Like your codebase, your rule system should evolve with your team, your tech stack, and your workflows. Treat your rules as part of your product.

Here’s how to build a culture of ongoing refinement:

Monitor and Iterate

• Watch PR comments - If reviewers keep pointing out the same issue, that’s a rule waiting to be created.
• Track onboarding questions - When new devs get stuck or ask for clarification, your rules (or docs) probably need an update. Keep track of onboarding questions from new developers
• Update rules after large-scale refactors - Big refactors change structure and logic. Make sure the rules reflect those shifts.
• Cross-reference related rules to improve discoverability - Rules are more useful when they connect to deeper references, examples, or related context.
  
  Photo by Mikhail Nilov

Handle Rule Deprecation

Not all rules age well. And as we all know tech evolves fast so best practices shift as well. Clean out the stale stuff and do it regularly.

• Mark outdated practices - Add a deprecated notice at the top.
• Update deprecated rules - Modernize where possible.
• Document migration paths - If rules are being retired, explain what to do instead and where it’s documented.

Rules should never be a liability. Make them an asset—living documentation that grows smarter and improves with your team and projects.

Follow cursor-rules.mdc for proper structure and consistency.

Wrap-Up

The smartest developers don’t just ship code. They build systems that teach the next dev, the AI assistant, and their future selves how to think.

By connecting cursor-rules.mdc with self-improvement.mdc, you're not just writing rules, you’re building a feedback-powered rule engine that teaches itself, helping your team stay consistent, efficient, and forward-moving.

No more repetitive code reviews. No more retraining your AI every time you switch context. Just structured, automated, and evolving workflows that scale.

Start building smarter today. Let your codebase grow its own brain.

🚀 Deploy your app with SashiDo in minutes. Start your Free Trial Now. And here is a quick Getting Started Guide for a smooth take off.

Happy Coding!

This self-improving rules setup was inspired by real-world examples from danmindru/page-ui open-source repo.

If you liked this post, you might want to also check out:

10 Pro Tips to Master Cursor Agent (and Boost Your Coding Flow)
Vibe Coding with AI Agents: Best Practices for Using Cursor with Node.js and SashiDo - Part 1
Vibe Coding with AI Agents: A Non-Developer’s Journey to Shipping an MVP on SashiDo - Part 2
How to Master Vibe Coding: Best Practices and Useful AI Tool

If you're using Cursor as your AI code assistant, you're already ahead of the game. Gone are the days of coding solo in the dark. With Cursor AI, your editor becomes your smartest teammate - one that can read your codebase, suggest improvements, and help you ship features faster and cleaner.

Whether you're a developer working solo, an indie hacker, a startup founder, or a team sprinting on a platform like SashiDo, these tips will help you go from using Cursor to mastering it. Let’s dive into the techniques that will optimize your workflow and enhance your coding rhythm.

1. Use Plan Mode as Your AI Architect

One of the most underused features in Cursor is Plan Mode. It’s designed to take the heavy lifting off your shoulders by generating clear and actionable implementation strategies.

Hit Cmd + N for a new chat, then Shift + Tab to switch into Plan Mode. The agent will:

1. Read and analyze your codebase
2. Understand your app's structure
3. Propose a clean, actionable implementation plan

This is your secret weapon for shipping new pages, integrations, or UI flows without overprompting.

💡 Pro Tip: The best results come when you let the agent take the lead initially. You can always tweak the plan later, but avoid micromanaging the AI from the start.

2. Master the Context Menu

Type @ in the chat to summon a context menu with files, folders, branches, past chats, and docs.

This lets you direct the agent’s attention precisely and avoids context overload.

Whether you're reviewing a specific branch, referencing past conversations, or pulling in errors from a linter, the context menu keeps your development focused and efficient.

3. Create Custom Slash Commands

Define your own workflows with /commands and lets cursor to automate repetitive work.

Create a folder of markdown-based commands like /pr for auto-generating PRs. This is a great way to maintain team standards while freeing up your time to focus on logic and implementation

Automate away the boring stuff so you can focus on the hard stuff!

4. Paste Images for UI Help

Trying to clone a design or get visual inspiration? Paste a UI screenshot directly into the chat and ask Cursor to replicate the layout.

For example, you might say:

*"Make my Top Artists page look like this." *

Cursor will then generate a matching layout, adjusting components and configs as needed. This feature is particularly useful for frontend developers working with SashiDo to quickly prototype screens.

Go from Design inspiration to functional UI, instantly!

💡 Pro Tip: Sometimes, if the LLM doesn’t quite get what you’re trying to explain, it’s much more effective to attach a visual example instead.

5. Duplicate Chats Strategically

Instead of cluttering your main thread with multiple directions, use the duplicate chat feature to experiment. It works like forking your development process - giving you space to test, iterate, and compare results without losing your main conversation.

This strategy is especially useful when exploring alternative solutions to complex UI or backend logic.

6. Watch the Context Window

Your context window is like memory bandwidth - keep it lean for best results when it gets full, quality drops.

To keep the conversation sharp, use /summarize to condense earlier parts of the chat or simply start fresh threads for new features.

Fresh contexts yield clearer, more actionable responses.

7. Monitor Usage Limits

If you're on a metered plan, toggle Usage Summary to track percentage, reset time, and model usage.

Perfect for cost-conscious startups and indie devs scaling efficiently.
Helpful for teams and budget-conscious devs.

8. Learn the Shortcuts

Speed is life. Here are a few favs:

Cmd + I -> Open agent
Cmd + / -> Switch model (GPT-5, Claude, etc.)
Cmd + N -> New chat

💡 Pro Tip: Customize in settings to better fit your flow.

9. Start Fresh Often

Long chats = overloaded context = bad answers.

The best Cursor users treat each chat like a mini sprint: start fresh for each feature or bugfix. This keeps your context clean, responses sharp, and productivity high.

Make it a habit: new feature, new chat. Bugfix? Start another one.

10. Time Travel with Checkpoints

Made a bad change? Roll back effortlessly with Cursor's Checkpoints.

It's like Git for your conversations - perfect for UI tweaks or logic reversions, A/B tests, or quick fixes.

This safety net gives you confidence to explore without fear of losing progress.

11. Bonus Hidden Gems

Here are a few lesser-known features worth exploring:

• Completion Sounds: Audible feedback when the agent finishes responding. Get a "ding" when the agent finishes!
• Mermaid Diagrams: Visualize complex app logic with just a prompt.
• New Layout Beta: Test a new layout with agents on the left, code in the center, and diffs on the right

Fin

Cursor isn't just another AI assistant. It's your coding co-pilot that understands your code, proposes implementation plans, and helps you ship clean, production-ready features faster.

The most effective Cursor users aren’t the ones who type the most prompts. They’re the ones who guide the agent smartly - using structure, context, and the right tools at the right moment.

So whether you're hacking together a new MVP, improving UX, spinning an MCP server or scaling a SaaS on SashiDo, these Cursor strategies will help you focus on what really matters - building great products!

🚀 Ready to take your AI-assisted development even further? Deploy your app with SashiDo in minutes. Start your Free Trial Now. And here is a quick Getting Started Guide for a smooth take off.

If you liked this post, you might want to also check out:

Vibe Coding with AI Agents: Best Practices for Using Cursor with Node.js and SashiDo - Part 1
Vibe Coding with AI Agents: A Non-Developer’s Journey to Shipping an MVP on SashiDo - Part 2
OpenAI’s New Apps SDK (Preview): What It Means and How to Experiment
How to Master Vibe Coding: Best Practices and Useful AI Tool

Multilingual communication is a social phenomenon. It does not develop because of technical prerequisites. It develops because there is a need, a desire in people to have it.

It is super easy to get “lost in translation” when you are trying to understand a movie, novel or even just a story told by a friend without knowing the nuances of the language used in the original content.

In business, it’s not enough to just rely on “Business English,” as some of the world’s biggest markets like China and Brazil do most of their operations in their local language.

Consumers all over the world prefer products and trust companies that provide localized content and services. Therefore to successfully speak to the world without losing the true meaning behind your message, it is essential to do it in the languages most familiar to your global audience.

Multilingual in Parse Server with SashiDo

Today SashiDo is the only provider that brings multilingual experience for the Parse Server app makers like you.

Since our customers are in more than 88 countries around the globe, we are confident that this feature will give them a tool to deliver more value to their customers. That's why we make it from scratch.

The new Multilingual Email templates and User-Facing pages are straightforward to use and require almost no coding at all. In SashiDo there are no limits on how many languages your applications will communicate with your customers.

Fin

To get started with the multilingual communication you need only to set up your locale preferences, and set up your templates in the SashiDo's Dashboard and to commit your custom pages into your application's repo.

We wrote this step by step tutorial that will guide you from start to the end in Configuring your Multilingual Email templates and User-Facing pages

Thanks, Благодаря, Merci, ¡Gracias!, Σας ευχαριστώ, Grazie, ありがとう, Děkuji, Hvala ti, धन्यवाद, Kiitos, Köszönöm, Благодарю вас!

Your SashiDo friends!

We are thrilled by all of the excitement that we see around Parse Server and Cloud Code development. We have seen many Cloud Code success stories, and at the same time challenges, for the Parse and SashiDo developers.

Today I would like to tell you about one significant addition to the SashiDo Platform, the Environment Variables, and the new Cloud Code Development Model.

Environment Variables

Every developer desires to build code that can be used in more than one environment. To do this in a clean and reusable fashion, the code should be able to accept configuration values at runtime. The configuration values customize the environment for the code: service credentials, custom URLs, file paths, and so forth. For example, many projects have distinct configurations for their development, test, and production environments.

In brief, using the Environment Variables is the best approach to design your code to work like an appliance.

Check out the 12factor config if you're interested in this field.

Parse.Config vs Environment Variables

Many of you who have some experience with Parse would say: "We have the Parse.Config, why we need another way to configure our apps?"

Yes, this is almost correct, but not really. Parse.Config was built mainly for configuring the Front-end side of your applications, for things like feature flagging, changing the look and feel settings or managing some contact information.

Parse.Config is a fantastic way to configure your application on the fly, but there few issues that make the Parse.Config inappropriate for every case. For example, every setting in the Parse.Config is public readable, in other words, any sensitive data should not be stored there!

All of this means that you need some secure way to store your credentials for Twilio, Stripe, Mailgun or any of the services you use in the Cloud Code.

In brief, the Environment Variables are the Parse.Config alternative for configuring the Back-end part of your application securely.

How to use the Environment Variables in the app's Cloud Code

Well, since the Environment Variables are very popular and they are used almost everywhere, NodeJS supports them as well. Let me give you an example of how the Environment Variables change your code.

Configuring Mailgun without Environment Variables

var mg = mailgun.client({
  username: 'api',
  key: "some_hardcoded_Key",
  public_key: "some_hardcoded_Public_Key"
});

And here is how the code will look like with Environment Variables.

var mg = mailgun.client({
  username: 'api',
  key: process.env.MAILGUN_API_KEY,
  public_key: process.env.MAILGUN_PUBLIC_KEY
});

As you can see in the first example, the code has the hardcoded credentials which make it not portable and insecure.

Setup your Environment Variables in the SashiDo's Dashboard

From the example above you already know how to use the Environment Variables in your application's Cloud Code. Adding them to the app environment is straightforward too. You only need to go to: Application -> Runtime -> Environment Variables

When you're done click on the Save & Deploy button, and that's it! :)

Fin

Environment Variables bring a new level of simplicity to work with the Parse Server Cloud Code. I hope you'll enjoy it.

Happy Cloud Coding!

Our team is very grateful for your ongoing and colossal support to SashiDo platform. We are pleased to announce the first beta version of the SashiDo Applications Metrics (in next couple of months we'll continue improving your experience with SashiDo by adding new data and insights piece by piece).

Explore your Usage

Get into details with your applications requests, storage, files, database, and traffic. We have a daily overview of all this data for 30 days and monthly insights for the last 12 months.

Find the patterns in your App

With the heat map metrics overview is much easier to discover the customer and application usage patterns. Which day of a week is essential for my business for example.

Understand better your Data

In every stage of the business lifecycle seeing the whole picture is one of the most important things. Knowing your data helping you to make the tough decisions with confidence!

Explore your app's Global Picture

Doing a global business online today is just in a click away. Every one of us wants to change the world and make it the better place! The SashiDo Metrics are here to show you the impact you made on the people all around the globe!

We are not done yet!

We won't stop here! A lot of cool new stuff is coming ... so keep up and stay tuned!

Parse Server and SashiDo users love the password reset and email verification features, but some of you have asked for better control over these experiences. Perhaps your customers don't speak English, or you have a well defined brand that you want these experiences to adhere to. Or maybe you just don't like your users knowing that you use SashiDo.io as your backend. Today we'll share with you an unparalleled control over your branding with Parse Server and SashiDo. The following features are accessible from your app settings page:

Email Templates

Password resets and email verifications require us to email links to your users. With Parse Server and SashiDo you have the ability to customize the email text very easy. Email templates use a simple markup language that replaces %username%, %email%, %appname%, and %link% with their appropriate values.

For example, the body:

Thank you for joining %appname%. We're excited to have you onboard. 
To access our premium features, please verify your email address by clicking this link: %link%.

Would send the following email to your users:

Thank you for joining AnyWall. We're excited to have you onboard.
To access our premium features, please verify your email address by clicking on this link: some link

Custom User-Facing Pages

Another good feautre in SashiDo with the Parse Server are the User-Facing pages. The Parse Server's password reset and email verification features are implemented with the Model-View-Controller design pattern. The Parse Server is the "controller" for your app and provides default views. Developers who wish to control the design of these pages can tell SashiDo to use modified versions of these pages instead. Each view is a simple and clearly written HTML/CSS/JavaScript page. Download any user-facing page and modify it as you wish. Put your modified version online and give us its address to replace that view in your app.

Consider the Password Reset workflow:

1. A user is mailed a link with which he or she can choose a new
   password
2. The user clicks the link and is forwarded to choose_password.html to select a new password.
3. The user submits his or her new password and he will receive a confirmation that the new password has been successfully changed by password_reset_success.html
4. If malicious users attempt to reverse engineer the password reset link, they are sent to invalid_link.html

Each of these three pages can be replaced in the app settings page in SashiDo Dashboard. You could add a corporate logo or stylesheets to each page. SashiDo will use your pages as a replacement for Parse Server defaults.

When you change the links in the app settings page you need somehow to deploy your custom pages to the application itself. Let me give you 2 simple ways to do this.

If you are not familiar with SashiDo yet, I want to share with you that we are creating a FREE Private GitHub repo for every application deployed in our platform in order to give you the best experience to collaborate with your colleagues, customize and deploy your Cloud Code with just a git push command. If you want to learn more about this feature you can take a look at our Cloud Code Tutorials Section.

For demo purposes, we have a public GitHub repo that demonstrates the basics of the integration. The demo repo is available at the following link:

• https://github.com/parsegroundapps/pg-app-tynwrjdecdmr69ke5d8fec6ixljzx5

CloudCode Public Static Pages

This is the easiest best way if you want just to customize these pages with your logos, stylesheets or some JavaScript.

Opening the repo mentioned above you can see in its structure the public directory. This is the directory where you can add all of your static assets, css, js, images including your HTML files.

When you open the public directory you can see another directory called pages and this is the directory where we suggest you to store your custom user-facing pages if you decide to follow this approach.

For your comfort we have uploaded all the user-facing pages that can be customized:

1. choose_password.html

This page is displayed when someone clicks a valid 'reset password' link. You should feel free to add to this page (i.e. branding or security widgets) but should be sure not to delete any of the form inputs or the JavaScript from the template file.

This JavaScript is what adds the necessary values to authenticate this session with the Parse Server.

The query params 'username' and 'app' hold the friendly names for your current user and your app. You should feel free to incorporate their values to make the page more personal.

If you are missing form parameters in your POST, the Parse Server will navigate back to this page and add an 'error' query parameter.

2. password_reset_success.html

This page is displayed whenever someone has successfully reset their password. This page will be called with the query param 'username'

3. verify_email_success.html

This page is displayed whenever someone has successfully verify their email address. This page will be called with the query param 'username'

4. invalid_link.html

This page is displayed when someone navigates to a verify email or reset password link but their security token is wrong. This can either mean the user has clicked on a stale link (i.e. re-click on a password reset link after resetting their password) or (rarely) this could be a sign of a malicious user trying to tamper with your app.

The custom user-facing pages URLs

If you follow this approach and you put your custom pages in <your-repo>/public/pages/<page>.html so your pages will be available after you deploy them to the repo on the following addresses:

• https://<your-sashido-app-address>.scalabl.cloud/pages/choose_password.html
• https://<your-sashido-app-address>.scalabl.cloud/pages/password_reset_success.html
• https://<your-sashido-app-address>.scalabl.cloud/pages/verify_email_success.html
• https://<your-sashido-app-address>.scalabl.cloud/pages/invalid_link.html

The final step after you're sure that your custom user-facing pages are live is to tell the Parse Server to use them.

And Yes ... it's that easy :)

Advanced Cloud Code

Following the same principles as the section above, this is the way when you need some dynamic or advanced behavior on that pages.

Sometimes you need to do some things behind the scenes when an error appears or the customer visits some of these pages. Here the Advanced Cloud Code is your friend.

SashiDo's Advanced Cloud Code functionality is actually an ExpressJS application with the ability to use custom NPM modules.

Here is what you need to know when you decide to follow this approach. What we are doing behind the scenes is to mount that ExpressJS application to the Parse Server Router. As you can see in the example we have defined a custom get routes:

• /advanced_choose_password
• /advanced_password_reset_success
• /advanced_verify_email_success
• /advanced_invalid_link

p.s: More information about how to use ExpressJS res you can find here:

• https://expressjs.com/en/api.html#res

If you want to access these routes you just need to do a GET request to the following URL:

• https://<your-sashido-app-address>.scalabl.cloud/advanced_choose_password
• https://<your-sashido-app-address>.scalabl.cloud/advanced_password_reset_success
• https://<your-sashido-app-address>.scalabl.cloud/advanced_verify_email_success
• https://<your-sashido-app-address>.scalabl.cloud/advanced_invalid_link

The final step after you're sure that your custom advanced user-facing pages are live is to tell the Parse Server to use them.

p.s: If you don't know what your handlers should return as a response take a look at the static user facing pages for ideas here:

• https://github.com/parsegroundapps/pg-app-tynwrjdecdmr69ke5d8fec6ixljzx5/tree/master/public/pages

Yes, it's that simple :)

SashiDo's Advanced Cloud Code approach will be the best option if you need to put some server-side logic on your user-facing pages.

The Advanced Cloud Code links:

• app.js
• package.json

If you want to learn more about the SashiDo's Cloud Code functionality and the Static WebSite Hosting you can take a look at the following sections:

• https://blog.sashido.io/tag/cloud-code/
• https://blog.sashido.io/tag/web-hosting/

Fin

I think this is all you need! You're GURU now! :)

Do not forget! If you have any questions you can always contact our support for further assistance.

Happy Coding!

If you build a website and map it to a custom address such as www.yourdomain.com, you can make it even easier for people to reach your site by typing simply yourdomain.com That web address without the www is called naked domain.

These days in the cloud era hosting of Naked domains with providers like SashiDo, Heroku, OpenShift and others it is a bit tricky, but not impossible.

You can simply do this by redirecting your naked domain address to the www.yourdomain.com

How to do it?

There are few easy ways to do it:

• Check out whether your DNS provider supports naked domains redirection.
• Buy a cheap VPS, install a webserver with redirection rule and add an A record to your DNS with the IP of the VPS.
• Use any other service that can do the things above. I'll suggest you one :)

Meet gowww.io redirect service for naked domains

Today I would like to show you the easiest way to handle the challenge with the naked domains www.gowww.io

The only thing you should do is go to your DNS provider and add the gowww.io IP address (the current IP address is 144.217.225.221) as an A record to your naked domain. See how the operation will look like if your domain is mydomain.com and you are using AWS Route53 DNS Service.

After filling in the IP address you just click on save and you are done. That's it!

How to test whether it is working?

The change you have made can take some time, because it depends on your TTL DNS settings. If you are using MacOS or Linux you can simply use nslookup or dig commands.

See how:

$ dig gowww.io
; <<>> DiG 9.8.3-P1 <<>> gowww.io
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 29329
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;gowww.io.			IN	A

;; ANSWER SECTION:
gowww.io.		59	IN	A	144.217.225.221

;; Query time: 69 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Nov 30 17:29:15 2017
;; MSG SIZE  rcvd: 42

Depending on your domain name if you see a line similar to this one, it means that you're in the game!

gowww.io.		59	IN	A	144.217.225.221

If you don't like the black screen of the terminal you can always use some web service to check this out:

• http://www.dnsqueries.com/en/dns_lookup.php
• http://ping.eu/nslookup/

Features of gowww

Just in brief see what gowww will do for you.

• When you open your naked-domain.com it will redirect to www.naked-domain.com
• When you open your naked-domain.com but with https gowww will automatically issue a SSL certificate with Let's Encrypt and will redirect to https://www.naked-domain.com

Yes, I know. This is boring stuff and yes, gowww saves us a lot of time.

Fin

That's it, guys. I hope that this article has saved you a lot of time in digging and searching for a solution or doing stuff you don't like :)

If you are a SashiDo customer and you want to host your website or www.domain.com take a look at this tutorial:

• Static web hosting with SashiDo

This blog post is aimed at showing you how to navigate your data in the SashiDo Dashboard and use the JavaScript SDK to perform the most commonly used operations while building a mobile application.

For this purpose we will be using an already existing set of example data - the Telerik Friends Sample App. If you are not familiar, such an example app can be created by navigating to a new application in Telerik Platform -> Data and clicking the Enable and use sample data button. The respective frontend code is available on GitHub. For simplicity's sake the examples below will be simplified to include only the most relevant bits and pieces of the process.

Vocabulary

Before proceeding, you should know how some of the most common terms, fields and features of Telerik Platform Backend Services translate to Parse Server.

Fields

Additionally all fields casing is transformed from pascal case to lower camel case to conform with the Parse Server and JavaScript conventions. E.g. the field CommentsCount is transformed to commentsCount.

Features

Cloud Code

Dashboard navigation 101

This is how our test application's structure looks like in Telerik Platform:

After migrating it to SashiDo we are presented with the following information in the SashiDo Dashboard:

On the left, you can see your classes and on the right the respective objects, with their relations, images and fields translated to their respective Parse Server alternatives. If you are curious in more details what and how is migrated, and what you would have to do manually, refer to the blog post Checklist for successful migration.

First steps

Alrighty, we have migrated the data, but our web application is still using Telerik Platform. Let's get through the hurdles and differences you might experience while first switching from Everlive's JS SDK to Parse's JS SDK. Each example will build up on top of the previous ones, so keep that in mind.

You can always refer to the Parse Docs where every functionality is explained in details.

Initialization

With Everlive you need to supply your AppID.

const Everlive = require('everlive-sdk');
const everlive = new Everlive('c9o5u3p9j4h9o5bx');

SashiDo requires your AppID, JavaScriptKey and ServerURL. Both can be found in AppSettings -> Security & Keys.

const Parse = require('parse');
Parse.initialize('17joQ7Azu9O1mTKdntp8h3IndS6h4VUDKFbNN5W3');
Parse.javaScriptKey = 'CsgJs1v0Dhw3cpeKmtVZL2PRKUI6dUbDbRQS5U4W';
Parse.serverURL = 'https://pg-app-r1q3oghvrb1q6ys6qev81p5ccp3sj2.scalabl.cloud/1/';

Authentication

The gateway to every application is its login/registration. In our Friends app, only registered users can create new Activities.

Telerik Platform:

const username = 'my_username';
const password = 'super_secret_password';

//register
everlive.users
    .register(username, password, {
        Email: 'my_email@sashido.io'
    })
    .then(() => console.log('registered!'));

//login
everlive.authentication
    .login(username, password)
    .then(() => console.log('logged in!'));

Parse:

const username = 'my_username';
const password = 'super_secret_password';

//register
const user = new Parse.User();
user.set('username', username);
user.set('password', password);
user.set('email', 'my_email@sashido.io');
user.signUp().then(() => console.log('registered!'));

//login
Parse.User.logIn(username, password).then(() => console.log('logged in!'));

Reading Activities

After we are logged into our application it's only natural to read some activities. The activities are something like the posts in your Facebook feed.

Telerik Platform:

const Activities = everlive.data('Activities');

Activities.get()
    .then(activities =>
        activities.result.map(activity => ({
            id: activity.Id,
            text: activity.Text
        }))
    )
    .then(activities => console.log(activities));

Parse:

const Activities = Parse.Object.extend('Activities');
const activitiesQuery = new Parse.Query(Activities);
activitiesQuery
    .find()
    .then(activities =>
        activities.map(activity => ({
            id: activity.id,
            text: activity.get('text')
        }))
    )
    .then(activities => console.log(activities));

Both will print the following:

[
    {
        id: "334cda51-b336-11e7-b6af-eddd2fe7d355",
        text:
            "It is finally time for graduation! Good job everyone, we made it."
    },
    {
        id: "334cda52-b336-11e7-b6af-eddd2fe7d355",
        text: "The most amazing sunset I have ever seen at Phuket, Thailand"
    }
]

Reading the comments for an Activity

In both platforms the comments have a relation. To their respective parent activity.

Here's how we can find the comments for the first activity in Telerik Platform:

const oneQuery = new Everlive.Query();
oneQuery.take(1);

Activities.get(oneQuery)
    .then(result => result.result[0])
    .then(firstActivity => {
        const query = new Everlive.Query();
        query.where().eq('ActivityId', firstActivity.Id);

        const Comments = everlive.data('Comments');
        Comments.get(query)
            .then(comments =>
                comments.result.map(comment => ({
                    comment: comment.Comment
                }))
            )
            .then(comments => console.log(comments));
    });

And in Parse:

const activitiesQuery = new Parse.Query(Activities);
activitiesQuery.first().then(firstActivity => {
    const Comments = Parse.Object.extend('Comments');
    const query = new Parse.Query(Comments);
    query.equalTo('activityId', firstActivity);

    query
        .find()
        .then(comments =>
            comments.map(comment => ({
                comment: comment.get('comment')
            }))
        )
        .then(comments => console.log(comments));
});

The result would be:

[
    {
        id: "3810cb01-b336-11e7-b6af-eddd2fe7d355",
        comment: "Thanks :)"
    },
    {
        id: "3810cb00-b336-11e7-b6af-eddd2fe7d355",
        comment: "Congratulations!"
    }
]

Creating an activity

Let's close the cycle by creating an activity. When creating an activity we need a Picture, Text and UserId of the creator.

For simplicity's sake we will skip the boilerplate code of getting a base64 of the picture we will be uploading. More on the topic you can find in the Parse Docs about files.

Telerik Platform:

const file = {
    Filename: 'picture.png',
    ContentType: 'image/png',
    base64: 'some-base-64'
};

everlive.users.currentUser().then(user => {
    return everlive.files
        .create(file)
        .then(response => {
            return Activities.create({
                Text: 'new activity!',
                UserId: user.Id,
                Picture: response.result.Id
            });
        })
        .then(() => console.log('activity saved!'));
});

The difference with Parse is that we have to set the acl so that only our user can edit the activity and anybody, including unregistered users, can read it.

const picture = new Parse.File(
    'picture.png',
    { base64: 'some-base-64' },
    'image/png'
);
picture
    .save()
    .then(() => {
        const currentUser = Parse.User.current();

        const activityACL = new Parse.ACL(currentUser);
        activityACL.setPublicReadAccess(true);

        const newActivity = new Activities();
        newActivity.set('text', 'new activity!');
        newActivity.set('picture', picture);
        newActivity.set('userId', currentUser);
        newActivity.setACL(activityACL);

        return newActivity.save();
    })
    .then(() => console.log('activity saved!'));

Fin

After going through these basic steps, you now know what your data will look like when it is migrated to SashiDo, where to find it, how to query it and how to create more data.

Make sure not to miss on our other blog posts, such as:

• Checklist for successful migration?
• Best practices in structuring SashiDo accounts
• How to start using GitHub with SashiDo
• How to set up iOS push notifications in SashiDo
• Android Push Notifications: How to start using FCM
• Static web hosting with SashiDo
• GitHub integration of Advanced Cloud Code
• Getting started with Background Jobs
• How to set up WebHooks on SashiDo
• Realtime with Parse Server Live Queries

Happy Migration!

We know migration to another MBaaS is not an easy business. With more than 4k successful migrations for the last year, we'd like to share with you the most appropriate order of steps to do your migration to SashiDo, along with few tricky moments you need to know.

Use them as a reference to smoothen your migration and to ensure you won’t forget any aspect of the process.

Here’s the short list of the recommended migration steps:

1. Database Migration
2. Files and Responsive Images
3. SDKs
4. Cloud code
5. Scheduled Jobs
6. Push Notifications certificates
7. Email templates
8. Set up your Host Name (CNAME)

Database Migration

As you already know, the Database schema of Telerik Platform is vastly different from the one of Parse Server (and any other backend for that matter). Furthermore, there’s no straightforward way to export your Telerik Platform database, this makes any kind of migration to another service a tad bit tedious.

Fear not, SashiDo has your back. We have developed an automated process that will export the data from your Telerik Platform application, transform it to the respective Parse Server format and import it into your SashiDo application’s MongoDB. All you have to do is click here and there{or contact us?}. You can see in details how each Telerik Platform field and/or feature maps to Parse here:

Crash course with Parse Server for Telerik Platform developers by SashiDo.

After the migration is complete, you can head straight to the Parse Docs and start using your data right the way.

Files and Responsive Images

As part of the migration automation we will also make sure to upload all used images from your Telerik Platform application to the respective S3 Bucket in SashiDo and replace all fields in the database accordingly. If you have to do it manually it may take 1-2 days, depending on the number of your files and for sure will raise your migration expenses.

To save you even more development time, we, at SashiDo also made sure to set-up a Responsive Images service compatible with the one at Telerik Platform. The service has the same API as the service you have used up until this point. E.g. https://res.sashido.io/1/your-app-id/resize=w:250,h:250,fill:cover/https://your-app.s3.amazonaws.com/large_image.png

If you have used the HTML helpers to resize your images, then we have more good news - we created a small library to assist you further in the transition to the new service. It’s a drop-in replacement of the current everlive.helpers.htmlHelper and can be used as follows:

var sashidoResponsive = new SashidoResponsive({ appId: 'your-app-id' });
sashidoResponsive.processAll();

SDKs

Parse Server has a wide range of open source SDKs at your disposal:

• For iOS & OSX
• For Android
• For JavaScript
• For .NET + Xamarin
• For Unity
• Parse PHP SDK
• For Arduino
• Embedded C
• Cloud Code (Parse CLI)

All you have to do is pick the right one for you. And rewrite a significant part of your application by replacing the Telerik Platform bits with the new, Parse Server ones. Head to the Crash course article to learn how to make the transition as seamless as possible for yourself.

Cloud Code

In the table below you can see how each Telerik Platform Cloud Code term maps to Parse Server.

The Cloud Code (Business Logic in Telerik Platform) being as different from any other backend as its database schema, you will be forced to rewrite it. This is a process we can’t automate, but we will do everything in our power to help you in this transition. As a starting point you can refer to the Crash course with Parse Server for Telerik Platform developers blog post and the Parse Docs - http://docs.parseplatform.org/cloudcode/guide.

Scheduled Jobs

Scheduled jobs, also known as Cloud or Background Jobs in Parse Server, will also have to be manually rewritten and scheduled. Make sure to watch out for collisions with the already running ones in Telerik Platform before their closing date.

Push Notifications certificates and credentials

There’s just one difference with the iOS certificates in Telerik Platform - in Parse Server you need to export them without a password before uploading them.
For Android, just set your SenderID and ServerKey. For more details, you can read our blog posts on the topics:

• https://blog.sashido.io/how-to-set-up-ios-push-notifications-in-sashido/
• https://blog.sashido.io/android-push-notifications-how-to-start-using-fcm/

Email templates

If Emails are a vital part of your application, then make sure not to leave them behind. There are two ways to manage email templates. First, go to AppSettings -> Emails & Hosting, where you can edit the templates for verification and password reset. Another way is to directly use mailgun in your cloud code, since any npm module is allowed, there are no limits.

Set up your Host Name (CNAME)

You can use static web hosting with SashiDo, you just need to set up your custom domain and CNAME in the Dashboard. You will also get free SSL encryption, courtesy of Let’s Encrypt. Here's an article explaining how to use hosting on SashiDo.

Don’t wait too much

We will not sugarcoat this for you. No matter if you choose SashiDo for your next MBaaS provider or not, you have a lot of work to do, and very short time to do it. We can only save you so much time, by providing automatic data migration and support assistance, but you have to do the heavy-lifting of completely rewrite your codebase by yourself. And don’t fool yourself, the sooner you start, the better.

Even before our early access, we had the vision to make SashiDo The Real Parse alternative.
As we promised you, step by step we include more and more features to our service so you wouldn’t miss anything.
And that’s just the beginning of our journey :)

We’re very excited to share the latest news - SashiDo now supports:

Background Jobs

Give you the option to write long running tasks, include them in your Cloud Code and set up how often you want to run them. Now you don’t have to worry how to implement functions which need to repeat frequently.

Read the tutorial

WebHooks

You want to code on a language other than JavaScript and integrate frameworks and technologies not supported by the Cloud Code? It’s now possible with Webhooks: it’s simple and easy but gives countless opportunities to expand the functionality of your applications.

Read the tutorial

LiveQueries

One of the key concepts behind Parse Server is the Query, which allows you to tell the Parse Server which object you need. This means that every time an object matching this query is changed, the server will see this immediately and push the new object data to you real-time. Want your app also to go real-time? It’s easier that ever!

Read the tutorial

Enhanced Logs

Logs now are improved, look beautiful now :) and more importantly: they are persistent and with the next updates of the Parse Server on SashiDo you’ll see much more useful debug information.

So ... What's next?

You’re probably wondering what’s coming next? Here’s a sneak peek of our road map:

• Two new regions: US and Australia
• Advanced Push Notifications
• MongoDB Automated Backups
• Documentation

We can’t wait for you to share your experience with the new features and show us what you’ve built with them.
Your feedback is important to us and helps us continue improving SashiDo.

We believe that you have to always push and improve yourself, we don’t think limits exist when you create something with passion and excitement.

Stay tuned with us, the best is yet to code :)