Leadership: The best way to manage your team

Team leadership may be a long and challenging path. The good thing is that leaders are made, not born. Every successful leader you see on TV, in your company, at your university, or even in your neighborhood developed their skills over time. If they were able to become strong leaders, so can you. Kevin Kruse, a Forbes contributor, and CEO of LEADx, define leadership as:

“Leadership is a process of social influence, which maximizes the efforts of others, towards the achievement of a goal.”

We like his approach because it emphasizes the importance of the “others” – our team! Leadership is not about you as the leader, it’s about the people you’re leading and what they will be able to achieve. If this seems overwhelming, relax, it just means you’re facing a new challenge. It may take a little extra effort, but in the end, you’ll gain new skills to help your team (and you) succeed. Here are five recommendations that help us lead our teams here at Oktana and turn our people into high-performers.

1. Leadership is not about you.

We’ve already said it, but it’s important enough to repeat. If you expect to get all the credit as the leader, you’re probably not in the right job. Assuming a leadership role requires a certain amount of expertise in specific areas. You weren’t promoted to leadership with the expectation that you’ll be doing the exact same work you’ve always done. There wouldn’t be any challenge in that. Your role is now to inspire your team and develop their capabilities so they can accomplish more. They might even be working on the same types of achievements you did before you moved into leadership. It’s their time to shine now. Your excellent leadership will shine through their accomplishments.

2. Great leaders connect.

Great leaders connect their teams. And it’s not just about having regular conversations. When we say “connect your team”, we mean “become a real support for them.” They’re challenged by you to become better professionals, but they’re also looking to you for help or instruction. If they don’t have your support, it may become an awful experience for everyone. It’s important to let them be independent in their work, just be sure your other responsibilities don’t take your attention away from their progress and needs.

Mauricio Villamayor, product designer at Oktana Paraguay shares his perspective:

“I always think of giving more independence to team members, but this pandemic makes me more aware of the need to be supportive and stay connected in a deeper way.”
Mauricio Villamayor – Product designer at Oktana Paraguay

3. The challenges are real.

Are you the kind of person who is always looking for a bigger challenge as soon as you finished the last one? That’s the sign of a great professional. If you see this pattern in your team, congratulations, you’re leading a high-performing team. The challenge for leaders is creating work experiences that take your teams to the next level. Map your expectations for the team and think of innovative and interesting projects to help them experience the professional growth they need. Challenges nourish your team. Feed them.

4. Learning goes both ways in team leadership.

Some people think employees learn from their leaders, but that leaders don’t learn from employees. Leaders provide knowledge and team members execute the tasks. We feel that’s not taking advantage of the full potential of the team. Our team brings expertise from design, development, marketing, administration, sales, and operations, from many countries. It’s taught us that leaders who don’t see their team members as potential sources of knowledge are missing an opportunity to see their business and markets from another perspective. That knowledge is pure gold in a world where everything is constantly changing.

5. Communicate efficiently.

Time is money, whether we’re talking about business or our daily lives. As you decide how to manage your team conversations, make sure those moments are as efficient as possible. Every team meeting needs an agenda so team members can easily understand the focus of the meeting and what they need to bring to the table. Use your channels well and try not to overwhelm your team. Stay strategic. Deliver the right message, through the right channel, at the right time.

“I believe Slack helps me a lot because it gets fast communication with my team members in real-time. Either I need to have 1:1 conversations or group arrangements, Slack is the platform where I can trust.”
Mauricio Villamayor – Product designer at Oktana Paraguay

Remember, becoming a great leader is a learning process that never ends. So whether you’re leading your first team or you’re an experienced leader, keep this advice in mind. Also, if you want to go deeper into leadership and team management, take a look at this trail about Empathetic Leadership and Managing the Salesforce Way.

Hope you have enjoyed it so far. We’re constantly striving to improve our leadership, join us. Our team knows what good leadership entails and we do our best to keep growing. We are a great place to work so if you’re interested in joining our team, go over to our available positions. Also, if you want to know more about our work, go check out our latest success stories.

The Simpsons, Legacy Code, and Maintainability for Salesforce Code

As soon as we start to code, we are taught many best practices, tricks, design patterns, and a huge “etc.” But it’s not until our first gray hair that we start to understand why all those best practices exist and why it’s important to apply them. I wanna write about my experience with legacy code and what worked for me with some examples.

First, let’s discuss what legacy code is, and compare different degrees of code quality with one of the most famous and beloved families ever.

Legacy Code and The Simpsons

When we hear about legacy code, the first thing we think is “old code”. So let’s start our analysis with the oldest member of the family.

Abraham Simpson (aka “Grandpa”)

Legacy sounds like something “old” that’s with us without us wanting it, just like the Simpsons family and Grandpa. He has aging problems (his memory is gone, he lost a kidney, he’s a little crazy…). He lives in a nursing home and his family tries to avoid him. For sure Grandpa is legacy code and any developer would prefer to resign rather than work on it. Grandpa is probably an old COBOL project the company avoids changing and migrating to newer technologies. The reason? Because it’s going to be really expensive and the entire business depends on it.

Homer J. Simpson

He is middle-aged. For some people he is old, for others, he is not (it depends how close in age the reader is). But he is dumb, he makes a lot of mistakes all the time. He drives under the influence, he is lazy and he has no idea what he’s doing at work and a BIG etc. He had some chapters where he tried to improve himself, but he wasn’t able to do it. If he were code, you wouldn’t be pleased to have to change it. I imagine Homer as a 15-year old Java application that is causing a lot of problems, but we are still trying to maintain it because we love it (because everyone loves Homer).

Bart Simpson

He is really young, 10 years old. He should be a nice kid who helps the elderly cross the street safely, but, he is always instead causing trouble for everyone. Marge needs to keep an eye on him every single second. If Bart is code, he is a React/Node.js/MongoDB application done by a startup with low budget and limited time to develop an MVP to secure an angel investor. He lacks testing, documentation, and has a lot of tech debt.

Lisa Simpson

Nice, smart, behaves well, never gets into trouble…in a few words, the daughter anyone would love. She tries to improve herself every single second. If Lisa were code, she would have a very good architecture, awesome code quality, comprehensive test suite, cool documentation, and good CI/CD. But there aren’t that many Lisas in the real world.

Marge Simpson

Finally, Marge, the mom of the family. She is some years younger than Homer. She tries to be good, support her family, and be a good citizen…but she has been in trouble, too. I would say she is the average project we work on. It has parts with good quality, parts with poor quality. Sometimes we make mistakes because of the coding quality and some tech debt that we have created knowing that we are going to pay a tax on it later.

So, what is legacy code?

In “Working Effectively with Legacy Code” (ISBN-9787111466253) Michael C. Feathers defines it as “code without a unit test.” I agree that code without “unit test” is legacy code, but I don’t consider that only having unit tests translates to your code being a modern “Lisa” program. I prefer to consider legacy code anything in which making any change is hard, costly, and risky because the maintainability is not high enough for different reasons that include:

Not having a comprehensive test suite
Poor documentation
Low code quality

I am pretty sure that while you are reading this, more than one of you is writing legacy code because legacy does not mean “old.”

Maintainability

According to IEEE, maintainability is:

“The ease with which a software system or component can be modified to correct faults, improve performance or other attributes, or adapt to a changing environment.”

So let’s discuss some topics that can make our code more maintainable.

Automated Testing

This is a must. We cannot change anything with any degree of trust without having a good automated test suite to support us.

Salesforce has a really good API to help developers with “unit testing” (the tests we mostly write in Salesforce are integration as we are interacting with a database instead of mocking it). Also, Salesforce requires us to have 75% of code coverage over all of the org to be able to promote to production, which is great…but is it enough?

For example, imagine you have this code:

This test passes, 100% code coverage. But another developer calls a new AccountCreator().insertNewAccount('') and the user sees an exception. Chances are the developer who created this class was doing test-driven development (TDD) but didn’t take time to think about the business restrictions (account name cannot be null or empty). There is no test checking that the code is doing this validation.

So having high code coverage is not enough, we have to make sure that we have covered all possible scenarios (happy paths, failures paths, border cases…all of them).

Documentation

We write code that lives for years and once in a while a person has to make a change. This person won’t be the same person as the one who coded it – even if they share the same ID number, phone number, or Instagram username, the programmer from the future probably has forgotten some aspect of the code. So we need some degree of documentation in our classes.

I wanna discuss the two main types of in-code documentation. First, let me show one example:

Let’s try to fix this with some tools:

*doc documentation (ApexDoc in the case of Apex)

A bunch of tools exists that allows us to put some special comments before classes and method declarations which can be parsed to generate documentation automatically. And the good part, you have the documentation in the same place as the code. In ApexDoc, the comment has to start with the /** instead of the regular /* Apex comment block and we have some tags to indicate what we are writing. Here’s an example:

@description: A high-level human-readable and understandable description of what the method is doing. I prefer to put an easily understandable and quick to read first line about what the method is doing. A really important detail that the developer needs to know about the method like if a web service is being used, I put that in the next line (but not going very deeply into implementation details).
@param: For each parameter, the method takes, we have to indicate the type, preconditions, and a description of what it is intended for.
@returns: The returning type and description (if the method is not void).
@throws: The exception it could throw and when it would do it.

The last topic about this is where the ApexDoc should be present. There are two approaches to this:

Public classes and methods
Every class and method

The main advantage of putting documentation in public classes and methods is that after we shared our code with the world, changing the contract we defined is not so simple (without breaking other people’s code) so we can be quite sure that the ApexDoc does not become obsolete (yes, we need to maintain the ApexDoc, too).

I prefer to put it everywhere and be sure the comments get updated when there are changes in the methods because private methods are code, too. They deserve respect and we will need to read them anywhere. We need to be kind to the next developer changing this code (especially because the next one could be ourselves of the future and I don’t want to aggravate them).

So now we have all our methods documented and we can skip reading that long and hard method that the piece of code I am working on calls (we go into details if and only if we need it).

Comments on implementation code

When I started to study computer science, a professor told me that comments are very important.

Well, I completely disagree with that idea in real life.

Code has to be self-descriptive and if we need to put a comment in it, we must be sure there is nothing else we can do to make the code more understandable without the comment. A comment line in the code is a new code line that needs to be maintained and it took development time to put it there. It also cannot be tested, so the chances are the comment ends up saying something that the code is not doing. Read the code carefully and tell me if you could find any discrepancies.

We will tackle how to reduce comment quantity shortly, but first check really good code comments here on Stack Overflow: Best Comments in Source Code You Have Ever Encountered

I really loved this one:

//When I wrote this, only God and I understood what I was doing

//Now, God only knows

Code Quality

This is the last topic I wanna cover today and I will only scratch the surface. In particular, I want to discuss how we can write our code to communicate with other developers in a way that is easier, faster, and clearer. Code should be self-explanatory and we should hide the implementation details until it is not possible to anymore. Ideally, our public method should be written as a declaration of the developer’s intentions and we leave the implementation details (the imperative part) to private methods (but we should not chain many private methods calls as it forces the developer to go forward and backward and is not optimal).

Let’s start with the method I showed you in the last section:

In this method, we find three different parts:

Collect data from parameters
Do business logic
Save and return the result (technically a method should do only one thing and do it well…this does two, but it is part of the trade-off we have to make in real life)

So let’s start with the first part:

We see the comment is wrong and useless so we delete it.
SOQL query is already declarative (the query has Salesforce best practices issues, but I do not want to focus on this right now), so we can’t hide any implementation details.
We have some variable declarations:
- accountScoresToReturn: This variable is self-explanatory: we are going to return this list.
- accountNames: Ok, they are account names but which account names??
- accountNameToId: Another good name, we know what we are going to store in it.
We have an iteration: This is a candidate to split into another method. Unfortunately, we can’t do it without impacting the overall performance or quality (we can’t return two values in Apex, so we need two methods with two iterations or a function that returns a string and has side-effects of populating the map). But reading this block we start to figure out what accountNames is for. We concatenate the accountNames with “,” between them, but we find out that the variable accountName is not expressive enough so we are going to look in the code to figure out what it is.

Second block:

This block mainly does two things:

It calls a webservice and parses the result
It gets the higher score accounts

And there are plenty of implementation details.

First, we tackle the invocation of the service. It requires the account name string and returns the parsed JSON object. So, let’s split this other method:

And our main method changes to:

Let’s tackle the second part of the business logic. Before we do this, do not forget to run the complete test suite we have. The business logic iterates over the parsedJson object and selects those that score higher than 5. So we are going to split it into another method which takes parsedJson and returns the List of selected accounts:

And our main method changes to:

Finally, we have the part of the code that returns data. Most of the time this part just returns a value or insert for the database.

Conclusion

One of the most important attributes of the work we do is the maintainability of the code we write. We must ensure we are using all the tools we have to enable this. There are hundreds more topics and tools to cover regarding how to create maintainable code, but everything starts with the three points I covered here:

Automated testing
Documentation
Code quality

Don’t forget you are going to spend more time reading the code than actually writing it. So you should take the time necessary to make it easier to read.

Coming back to our friends, we have Maggie:

Maggie is just a baby, she is learning the world. Everything she learns can lead her to become Lisa or Homer, just as the project you are working on right now. So, I hope these recommendations help your project to become Lisa and not Homer (even though we still love him).

If you’ve made it this far, thanks for reading! Also, if want to read more about code, check our latest articles here.

Heroku: Simplify and improve your cloud infrastructure

Data plays an enormous role in the success of any organization. Collecting and quantifying pertinent information builds a stronger roadmap for growth. Because of this, companies are collecting and storing data to forecast future trends and develop action plans. That’s a lot of data to manage and most companies don’t have the right technology in place. This is where the cloud sweeps in to save the day. Cloud platforms enable companies to store large volumes of data to repurpose for business transactions. As a result, cloud infrastructure demand is growing for businesses of all sizes, as they have come to realize the massive benefits and potential of utilizing cloud components. Heroku is a first-class platform that helps developers scale more effectively.

What is Heroku?

Heroku is a platform as a service (PaaS) cloud that supports several programming languages and is part of the Salesforce Platform. Because it supports the most relevant programming languages used in the industry, it has become a popular tool for enhancing cloud infrastructure. Developers, teams, and businesses of all sizes use Heroku to deploy, manage, and scale apps. Using bi-directional synchronization, Heroku unifies the data in your Heroku data with your Salesforce CRM data. Additionally, Salesforce Trailhead was built and launched on Heroku.

3 ways Heroku enhances cloud infrastructure:

Several Programming Languages: Initially, Heroku only supported Ruby on Rails. However, over the years it expanded to include other languages such as, Java, Node.js, Scala, Clojure, Python, PHP, and Go. The benefit here is the ability it provides users to create applications that are robust and versatile.

Rapid Delivery: Developers are able to deploy their code to Heroku with a one-line command in the terminal. Having all the power of Amazon Web Services (AWS) in the background, but without having to take care of setting up its infrastructure. Heroku has it all covered for you!. Access to all of these resources and capabilities massively cuts down project time and allows developers to focus on creativity and higher-level work.

Scalable Functionality: Heroku allows developers to construct while not having to sacrifice impressive UI and effective application functionality. Heroku is able to accommodate spikes and dips in traffic without having to purchase more hardware. The system is able to cope with higher loads of users or more traffic reaching the system.

As you can see, Heroku has many features that simplify and improve cloud infrastructure at a very granular level. By utilizing the Heroku platform, developers are able to build applications that are efficient, visually pleasing, and all at a fraction of the time and cost it would take to develop on other platforms.

Oktana’s Experience

Here at Oktana, we are avid users of the platform and always seek out the best technologies to leverage for our customers. We’ve used Heroku to develop a number of outstanding applications across several different industries. Among them, you can find a Leading Investment Firm, a Fintech Company, and MedZed.

We’ve seen firsthand the kind of power Heroku brings to drastically improve application development. That’s why we’re extremely proud to announce that we’ve recently received a Specialization Badge for outstanding Heroku development from Salesforce! We’re super excited to be recognized for our expertise and it motivates us to develop even more applications with the platform. We think it’s a great tool and highly recommend it to developers who really want to extend cloud infrastructure to the next level.

Salesforce Certification: MuleSoft Certified Developer

What is MuleSoft?

Acquired by Salesforce in 2018, MuleSoft is a SaaS company with a world-class industry presence. MuleSoft provides integration software to connect applications, data, and devices. At its core, it allows you to:

Efficiently build APIs
Manage your API users
Easily connect existing systems, regardless of the technologies used

From a developer perspective, MuleSoft streamlines the process of integrating various systems, whether that includes new APIs, Salesforce, ERP, or legacy applications. It is a unique technology in that you can program from a graphical abstraction and create flows with simple tools – a very different environment when it comes to software development.

For the customer, MuleSoft means you can connect all corners of your system, including Salesforce, and also reduce development time when building new APIs.

As the platform grows, MuleSoft is only becoming more powerful.

With MuleSoft’s Anypoint Security, security and threat protection can be automated at every layer for ISO 27001, SOC 2, PCI DSS, and GDPR compliance.
The MuleSoft Anypoint Platform™ allows themes to launch applications 3x faster and increase productivity by 300%.
API Community Manager enables MuleSoft customers to manage their API users in a community, leveraging Salesforce Community Cloud technology.

Over the years, our focus has been helping customers integrate their systems with Salesforce, whether through custom methods or integration with third-party services. We have encouraged our developers to achieve the MuleSoft certification. This has allowed us to partner with multiple companies that needed help integrating with MuleSoft.

How one of our partners uses MuleSoft

We recently completed a MuleSoft integration that allowed new data to be entered into a field within a mobile app, then copied and inserted into Salesforce as a new record. To complement this, we also built new automated email workflows to save Sales time when communicating with customers.

The first step of this project was a synchronization between Mulesoft, Web Services and a REST API. Using AWS and Python, we batched normalization of data. To automate this process, they used Salesforce Process Builder.

MuleSoft Certification

Isidro and Isaias, two developers who have become certified as part of their growth plan at Oktana, agreed that a month of full-time studying is required to pass the exam for the MuleSoft Certified Developer Level 1 exam. For those not dedicating this amount of time, they suggest you allocate two months to study.

Even though there are no prerequisites for this certification, they recommend having a background knowledge of REST API services, the basics of web concepts, HTTP requests and that you know how these work from a server perspective.

Isaias found the hardest topic was error handling, given that MuleSoft has its own logic to solve these issues and it is not easily related to other programming languages. The solution he found was to put the theory into practice by creating a fairly simple app and run flows, this way you understand the behavior of the app and what needs to be done for the app to behave differently. He mentioned that MuleSoft is highly versatile and offers multiple tools to use without the necessity of learning every existing tool.

Isidro thought the most interesting thing about this certification is that it allows developers to develop what can typically take several weeks in only a few days.

Here are some study materials as you prepare to become a MuleSoft Certified Developer:

The developers on our team who have worked on MuleSoft projects agree certification is fundamental to working with the technology. The material covered ensures you have the necessary knowledge of APIs and architecture required to work efficiently and to integrate other services. MuleSoft is widely used and growing within the market.

Equipment requirements for the exam:

Webcam
Microphone
Minimum operating system: Windows Vista / Mac OS x10.5
Compatible browser: Google Chrome or Mozilla Firefox.
Minimum RAM: 1024 MB

If you are part of our team, Oktana will provide you with some extra resources such as mock tests to help you successfully pass the exam and continue to develop your career. If you’re interested in joining our team, check out our job offers at Oktana Careers.

API Testing with the Karate Framework

This article has two goals. The first is to find interesting information about API Testing with Karate. The second is to help you discover how interesting test automation is and dive deeper into the knowledge behind the passionate job of testing.

And why testing and not Quality Assurance? In this topic, I follow Michael Bolton when he says “Testers: Get Out of the Quality Assurance Business” Words matter and this is a matter of expectations management: we cannot promise something we cannot accomplish.
Michael Bolton

The Forgotten Layer of the Test Automation Pyramid

When we think and design a testing strategy we should not forget The Forgotten Layer of the Test Automation Pyramid: The service layer.

Here is where we need to mention the test automation pyramid. This concept is introduced by Mike Cohn in his book Succeeding with Agile.

He describes three levels of test automation, their relationship, and their relative importance. The base layer consists of unit tests and the top layer corresponds to user interface-level tests.

Many times when we start testing without a proper strategy we end up doing the opposite: investing most of the time and the effort in UI tests, which are more expensive to develop and maintain than unit tests. Also we can forget to develop tests for the service level, that’s why they call it the forgotten layer.

As Joe Collantonio described some years ago now, API testing is becoming more and more important. So even if we agree or not with the test automation pyramid schema, it reminds us that we have to pay attention to API testing as part of our strategy.

Software Development Life Cycle

We’re into a spatial representation of the job. As we move down in the testing pyramid, the tests are cheaper, easier to develop, and can find issues in earlier stages, which makes them easier and cheaper to fix than in later stages.

This can be seen as moving left in the Software Development Life Cycle (SDLC), so many teams are involved in Shift Left Testing. Is that enough? It’s not, but it’s a really good move. Which is the next step? Continuous testing. Involve testing in every stage of the SDLC, doing it efficiently, doing it repeatedly, as part of the whole process.

Here is when selecting the right tools becomes important: a testing tool that can integrate with our CI (continuous integration)/CD (continuous delivery) systems is a great value.

API Testing Resources

As API testing becomes more and more important, we can find a lot of sites to help us learn more about it. I can suggest just a couple of them which I found very useful:

Learn more about the Karate framework

Why is Karate so attractive? Because it’s an open-source tool that combines API test-automation, mocks, performance-testing, and even UI automation into a single, unified testing framework.

Let’s take a look at some of the benefits:

Language neutral
Suitable for non-programmers
Elegant DSL syntax
Built on Cucumber / BDD Syntax
Integrates into existing CI/CD
Good documentation
Good demos

This Hello World example gives an idea of how simple yet powerful it is.

Peter Thomas provides a deeper explanation in his Webinar on Micro-services Testing With Karate.

I found really good arguments about how we can leverage the goods of Karate for our own project. Learn more in the following example: Karate, the black belt of HTTP API testing?.

Some points that look interesting are:

Tests = Documentation: tests are so easy to read that you can document your API with your tests. And as you have to maintain your tests as the API changes, you have your documentation always up to date.

Simple: Karate takes care of complexity so you don’t have to worry about Json processing as Karate takes care of that.

Re-use Karate tests in Gatling to do performance testing: having the power of Gatling based on the API tests you already have is a big win.

Comprehensive and detailed reports: Karate brings powerful and detailed reports that makes reading the status of our tests very easy. It’s also helpful to debug and troubleshoot problems when you get failures. If you add the benefit of Gatling reports it’s like having two superpowers.

Data Driven Testing: you can run your tests through tables.

Mocks fake HTTP servlet: you can execute your tests with a mock server that implements your API.

Karate vs Rest-assured

Do you need to decide which tool suits better for your needs?

Refer more about the following comparison here.

Extra sources about Karate API Testing

I found very useful the following example in Test Guild site.
You can also check this demo.

Conclusions

I found Karate can be a great option for automating the checks in the forgotten layer, integrating it in your CI/CD schema, also re-using your tests as the documentation of your API and for performance testing.

Is the right tool for you? It depends on your particular project, your needs, and your team. If you want to add the API testing to your strategy, you don’t have too much time and you want to make it simple, it seems like a great option.

Learn more from our team here, or check out our testing services.

App Development with Salesforce Technologies

Working together with our partners to bring ideas to life is one of the driving forces behind everything we do here at Oktana. That’s why when Huge approached us to help them with app development for Stanley Security; we leaped at the chance.

Stanley is a large security company specializing in commercial security systems. They needed a tool for their field sales team to use on the go that showcased their current product offerings. Also, they preferred to manage the process through the app, on either computers or tablets.

Huge has excellent skills in front-end development and was planning to develop the app and the UI/UX elements internally. But they needed a partner to help complete the backend work and sync everything up with Stanley’s Salesforce instance. That’s where the team at Oktana came in. Huge was able to focus on designing a front-end experience that would satisfy Stanley’s sales team. Meanwhile, Oktana could focus on a seamless experience on the back end.

How do the front and the back of this application work, and what did it take to make them play nicely? The front-end app was built utilizing React and Node.JS, managed with a Postgres database that Huge hosted on Heroku. For our backend development, we needed to make sure everything tied into the Postgres database correctly. To do that we utilized Heroku Connect to transfer between the front-end database and Salesforce. Additionally, we mapped all the data so that everything was stored where it needed to be on both ends of the application process. This application’s design was for interfacing with Stanley’s Salesforce organization, and it required a Salesforce login to access the app and all of its features. The login ensured that anyone using that app is a part of the sales team at Stanley.

Now, beyond the basic connective functionality, we needed to complete all aspects of the sales cycle through this app. This included allowing the sales team to send emails for clients with sales details and other information. To make that happen, we built an email tool using Apex and Visualforce. Stanley also wanted to close sales within the app, so we built in Adobe Sign functionality. Sales contracts could be signed digitally, and Zuora payment systems facilitated immediate payment. The final step was to synch the new data with the Salesforce organization.

The key technologies used in this project include:

Salesforce
Heroku
Postgres
React
Node.JS
Heroku Connect
Apex
Visualforce
Adobe Sign
Zuora

This project allowed us to work collaboratively with another development team to build different parts of an app. We’ve been able to successfully demonstrate our skill and ability to understand other’s work and apply it to our goals.

We’re looking forward to working with both Huge and Stanley again in the future. If you have a project that we can help you with, please be sure to let us know!

Learn more from our team here, or check out our custom development services.

Building Demos and Prototypes at Oktana

Everyone at Oktana is the best of the best at what they do and the incredible people that make up the Demos and Proof of Concepts team lead by Gonzalo is the perfect example of that. Whether it’s a Salesforce, mobile, or web project the team works hard to make our client’s dreams and ideas and make them a reality. The needs of our clients always come first and as such the team has developed into an extremely agile machine that is capable of producing and iterating on projects quickly while responding to new and changing requests.

The Demos and Proof of Concepts team’s role are to help our clients work through the entire prototyping process. First, we bring on all stakeholders and map out what the client’s goals and vision for the project are. The team is extremely adaptable and capable of discussing tasks at a very high level regardless of how fleshed out the idea is. Once all these ideas are captured the design team here at Oktana gets to work on designing the prototype. The design process here is highly iterative as we want to make sure our work is aligning with all of our client needs.

Once the design has been completed, the assets are then passed on to the engineering team. The engineering team then takes pre-built templates and reworks them into a working prototype for the project at hand. They continue to iterate on the concept with the client to ensure that it meets their needs. Once this process is completed the client will either decide to move forward on the development of the full product or not. If they opt not to move forward all code is then scrapped and the team moves on to its next project.

The Demos and Proof of Concepts team does incredible work for our clients with very little notice. They’ve built demos and prototypes that have been used for presentations in front of thousands of people at major conferences. If you’re ever in need of a demo or prototype then our team is here for you.

Building Demos and Prototypes Tailored to Your Needs

If you are a Salesforce partner looking to partner with experts to help you provide the best custom app development solutions to your clients Contact us. Our team will give you more information about these services.

Lightning Experience vs. Salesforce Classic: Is the Lightning Experience Revolutionizing Salesforce?

User experience is a huge factor in how a particular platform is perceived by end users and ultimately defines whether or not they will adopt to utilizing the platform. User interfaces that are choppy and lack visually appealing features tend to fall by the wayside because they are not engaging and they’re more than likely not as functional as they should be. For example, Salesforce updated their platform by implementing the Lightning Experience; a new and exciting way to view and access your Salesforce profile, as opposed to the duller, less visually satisfying Classic mode.

Well, perhaps, we can lay out the pros and cons of each Salesforce feature and establish how each comes with its own set of benefits. Lightning or Classic, you ask?

As the predecessor of the Lightning Experience, Salesforce Classic provides users with plenty of resources to complete their daily work tasks. It comes fully stocked with all of the typical CRM capabilities that ISVs/admins will utilize daily such as, accounts, leads, opportunities, campaigns, etc. Additionally, developers can use JavaScript source codes to build out tools like Process Builder, Visual Workflow, or code-driven approaches.

Salesforce Classic

Salesforce Classic has proven to be an optimal solution over the years, however, there’s a sleeker and more intuitive Salesforce UI that’s on the horizon; the Lightning experience! It has an entirely different user interface for Salesforce.com (SFDC) and it possesses some of the core Salesforce classic features as well. Additionally, it has many new cloud-based features and Salesforce objects are given a cleaner, fresher and overall more visually appealing look. The major goal of the Lightning experience was to enhance the usage of data and tools by minimizing the clickthrough rate so that Sales Reps could perform their job functions quickly and easily. AND – it’s completely mobile responsive.

Lightning Experience

The weigh-in?

While the Lightning experience looks awesome, it still has some catching up to do in terms of not having the most utilized Salesforce classic features embedded into its interface. Also, developers are not able to continue to use JavaScript/Visualforce coding libraries and some AppExchange apps might not be supported in the Lightning experience. If you’re a Salesforce party that has not yet fully acclimated to Salesforce classic and have no users/developers or system admins in your Org, it’s definitely best to go straight to the Lightning experience and build out your Org on this platform.

However, if you’ve heavily delegated all of your work tasks within Salesforce Classic, it may better serve to you to wait it out until Lightning experience gets up to speed and fully incorporates features like territory management for sharing and assigning accounts, Public Knowledge Base, Live Agent, Macros, among other features that streamline and simplify workplace functionalities.

As you can see, user experience plays a large role in both viewing formats. With Salesforce Classic, usability depends more on functionality and streamlining work whereas Lightning experience tends to focus more on the “look and feel.” The Lightning experience is definitely the way of the future and we suggest a slow transition whereby switching back and forth between each mode may be the ideal approach until Lightning incorporates more features for functionality. With that being said, we think both Salesforce Classic and the Lightning experience both have much to offer, however, Lightning is the new frontier in the Salesforce arena and eventually, we’ll all want to entirely jump on the bandwagon!

Check out our new article about Salesforce Classic vs Lightning: More than a pretty interface.

TrailheaDX or Dreamforce: Which is better for Developers?

As a platform development services company, we value hard work, dedication, passion and really honing in on the complexities of building out these environments. This means that our developers are thoroughly examining the structure of these platforms from a very granular level and building a foundation that will thoroughly support the development process. Oktana’s talented team of developers and designers truly embody these core qualities, however, we know that collaboration and eagerness to share and learn are what also makes us grow as a company.

TrailheaDX vs. Dreamforce

This starts with attending conferences and events that serve as a sounding board for like-minded technology professionals to bounce ideas around and come up with innovative and tech-forward strategies for development services. One such event is TrailheadDX; a Salesforce conference that welcomes tech companies from all over the world to attend and share best practices for the tech industry, especially with regard to the Salesforce platform.

We recently had the pleasure of attending this year’s TrailheaDX conference in San Francisco for the first time ever! We were pleasantly surprised by the conference, specifically with how much it focuses more on platform development, which is what we here at Oktana marvel in. On a much smaller scale than Dreamforce, TrailheaDX allows companies like ours to really shine and network with individuals who share these similar interests.

TrailheaDX provides a more intimate approach to presenting subject matter panels for topics like automation processes, cloud environment optimization, omnichannel customer environments and panels for just overall improving platform efficiency. Furthermore, since its a smaller venue there’s more face time with product managers, engineering team leads and industry professionals to really share and discuss industry trends. This is also a big plus because you have direct access to decision makers which can expedite future partnerships.

With keynote speeches from Salesforce Chairman & CEO, Marc Benioff, to Star Wars actor, Mark Hamill, we found that TrailheaDX still carried the same weight and star power as Dreamforce, but it caters more to developers which was especially exciting for Oktana. We think it’s tailored specifically for developers and that if you’re a high-level developer you’ll definitely benefit from attending the conference, so we encourage those who specialize in platform development to attend TrailheaDX as well as Dreamforce!